@azure/arm-redisenterprisecache 4.0.0 → 5.0.0-beta.1

package/dist/esm/models/models.d.ts

@@ -0,0 +1,1573 @@
+/**
+ * This file contains only generated model types and their (de)serializers.
+ * Disable the following rules for internal models with '_' prefix and deserializers which require 'any' for raw JSON input.
+ */
+/** A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results. */
+export interface _OperationListResult {
+    /** The Operation items on this page */
+    value: Operation[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _operationListResultDeserializer(item: any): _OperationListResult;
+export declare function operationArrayDeserializer(result: Array<Operation>): any[];
+/** Details of a REST API operation, returned from the Resource Provider Operations API */
+export interface Operation {
+    /** The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write", "Microsoft.Compute/virtualMachines/capture/action" */
+    readonly name?: string;
+    /** Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure Resource Manager/control-plane operations. */
+    readonly isDataAction?: boolean;
+    /** Localized display information for this particular operation. */
+    display?: OperationDisplay;
+    /** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+    readonly origin?: Origin;
+    /** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+    readonly actionType?: ActionType;
+}
+export declare function operationDeserializer(item: any): Operation;
+/** Localized display information for an operation. */
+export interface OperationDisplay {
+    /** The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft Compute". */
+    readonly provider?: string;
+    /** The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job Schedule Collections". */
+    readonly resource?: string;
+    /** The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual Machine", "Restart Virtual Machine". */
+    readonly operation?: string;
+    /** The short, localized friendly description of the operation; suitable for tool tips and detailed views. */
+    readonly description?: string;
+}
+export declare function operationDisplayDeserializer(item: any): OperationDisplay;
+/** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+export declare enum KnownOrigin {
+    /** Indicates the operation is initiated by a user. */
+    User = "user",
+    /** Indicates the operation is initiated by a system. */
+    System = "system",
+    /** Indicates the operation is initiated by a user or system. */
+    UserSystem = "user,system"
+}
+/**
+ * The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" \
+ * {@link KnownOrigin} can be used interchangeably with Origin,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **user**: Indicates the operation is initiated by a user. \
+ * **system**: Indicates the operation is initiated by a system. \
+ * **user,system**: Indicates the operation is initiated by a user or system.
+ */
+export type Origin = string;
+/** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+export declare enum KnownActionType {
+    /** Actions are for internal-only APIs. */
+    Internal = "Internal"
+}
+/**
+ * Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. \
+ * {@link KnownActionType} can be used interchangeably with ActionType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Internal**: Actions are for internal-only APIs.
+ */
+export type ActionType = string;
+/** Common error response for all Azure Resource Manager APIs to return error details for failed operations. */
+export interface ErrorResponse {
+    /** The error object. */
+    error?: ErrorDetail;
+}
+export declare function errorResponseDeserializer(item: any): ErrorResponse;
+/** The error detail. */
+export interface ErrorDetail {
+    /** The error code. */
+    readonly code?: string;
+    /** The error message. */
+    readonly message?: string;
+    /** The error target. */
+    readonly target?: string;
+    /** The error details. */
+    readonly details?: ErrorDetail[];
+    /** The error additional info. */
+    readonly additionalInfo?: ErrorAdditionalInfo[];
+}
+export declare function errorDetailDeserializer(item: any): ErrorDetail;
+export declare function errorDetailArrayDeserializer(result: Array<ErrorDetail>): any[];
+export declare function errorAdditionalInfoArrayDeserializer(result: Array<ErrorAdditionalInfo>): any[];
+/** The resource management error additional info. */
+export interface ErrorAdditionalInfo {
+    /** The additional info type. */
+    readonly type?: string;
+    /** The additional info. */
+    readonly info?: any;
+}
+export declare function errorAdditionalInfoDeserializer(item: any): ErrorAdditionalInfo;
+/** Describes a database on the Redis Enterprise cluster */
+export interface Database extends ProxyResource {
+    /** Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Default is TLS-encrypted. */
+    clientProtocol?: Protocol;
+    /** TCP port of the database endpoint. Specified at create time. Defaults to an available port. */
+    port?: number;
+    /** Current provisioning status of the database */
+    readonly provisioningState?: ProvisioningState;
+    /** Current resource status of the database */
+    readonly resourceState?: ResourceState;
+    /** Clustering policy - default is OSSCluster. This property can be updated only if the current value is NoCluster. If the value is OSSCluster or EnterpriseCluster, it cannot be updated without deleting the database. */
+    clusteringPolicy?: ClusteringPolicy;
+    /** Redis eviction policy - default is VolatileLRU */
+    evictionPolicy?: EvictionPolicy;
+    /** Persistence settings */
+    persistence?: Persistence;
+    /** Optional set of redis modules to enable in this database - modules can only be added at creation time. */
+    modules?: Module[];
+    /** Optional set of properties to configure geo replication for this database. */
+    geoReplication?: DatabaseCommonPropertiesGeoReplication;
+    /** Version of Redis the database is running on, e.g. '6.0' */
+    readonly redisVersion?: string;
+    /** Option to defer upgrade when newest version is released - default is NotDeferred. Learn more: https://aka.ms/redisversionupgrade */
+    deferUpgrade?: DeferUpgradeSetting;
+    /** This property can be Enabled/Disabled to allow or deny access with the current access keys. Can be updated even after database is created. Default is Disabled. */
+    accessKeysAuthentication?: AccessKeysAuthentication;
+    /** Specifies which keyspace events should trigger notifications. Default is an empty string, meaning this feature is disabled. When enabled, at least 'K' (keyspace events) or 'E' (keyevent events) must be present. For example, 'AKE' enables all standard events. See https://redis.io/docs/latest/develop/use/keyspace-notifications/ for the complete list of event types. */
+    notifyKeyspaceEvents?: string;
+}
+export declare function databaseSerializer(item: Database): any;
+export declare function databaseDeserializer(item: any): Database;
+/** Properties for creating Redis Enterprise databases */
+export interface DatabaseCreateProperties extends DatabaseCommonProperties {
+    /** This property can be Enabled/Disabled to allow or deny access with the current access keys. Can be updated even after database is created. Default is Disabled. */
+    accessKeysAuthentication?: AccessKeysAuthentication;
+}
+export declare function databaseCreatePropertiesSerializer(item: DatabaseCreateProperties): any;
+export declare function databaseCreatePropertiesDeserializer(item: any): DatabaseCreateProperties;
+/** This property can be Enabled/Disabled to allow or deny access with the current access keys. Can be updated even after database is created. */
+export declare enum KnownAccessKeysAuthentication {
+    /** Disabled */
+    Disabled = "Disabled",
+    /** Enabled */
+    Enabled = "Enabled"
+}
+/**
+ * This property can be Enabled/Disabled to allow or deny access with the current access keys. Can be updated even after database is created. \
+ * {@link KnownAccessKeysAuthentication} can be used interchangeably with AccessKeysAuthentication,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Disabled**: Disabled \
+ * **Enabled**: Enabled
+ */
+export type AccessKeysAuthentication = string;
+/** Properties of Redis Enterprise databases, as opposed to general resource properties like location, tags */
+export interface DatabaseCommonProperties {
+    /** Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Default is TLS-encrypted. */
+    clientProtocol?: Protocol;
+    /** TCP port of the database endpoint. Specified at create time. Defaults to an available port. */
+    port?: number;
+    /** Current provisioning status of the database */
+    readonly provisioningState?: ProvisioningState;
+    /** Current resource status of the database */
+    readonly resourceState?: ResourceState;
+    /** Clustering policy - default is OSSCluster. This property can be updated only if the current value is NoCluster. If the value is OSSCluster or EnterpriseCluster, it cannot be updated without deleting the database. */
+    clusteringPolicy?: ClusteringPolicy;
+    /** Redis eviction policy - default is VolatileLRU */
+    evictionPolicy?: EvictionPolicy;
+    /** Persistence settings */
+    persistence?: Persistence;
+    /** Optional set of redis modules to enable in this database - modules can only be added at creation time. */
+    modules?: Module[];
+    /** Optional set of properties to configure geo replication for this database. */
+    geoReplication?: DatabaseCommonPropertiesGeoReplication;
+    /** Version of Redis the database is running on, e.g. '6.0' */
+    readonly redisVersion?: string;
+    /** Option to defer upgrade when newest version is released - default is NotDeferred. Learn more: https://aka.ms/redisversionupgrade */
+    deferUpgrade?: DeferUpgradeSetting;
+    /** This property can be Enabled/Disabled to allow or deny access with the current access keys. Can be updated even after database is created. */
+    accessKeysAuthentication?: AccessKeysAuthentication;
+    /** Specifies which keyspace events should trigger notifications. Default is an empty string, meaning this feature is disabled. When enabled, at least 'K' (keyspace events) or 'E' (keyevent events) must be present. For example, 'AKE' enables all standard events. See https://redis.io/docs/latest/develop/use/keyspace-notifications/ for the complete list of event types. */
+    notifyKeyspaceEvents?: string;
+}
+export declare function databaseCommonPropertiesSerializer(item: DatabaseCommonProperties): any;
+export declare function databaseCommonPropertiesDeserializer(item: any): DatabaseCommonProperties;
+/** Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Default is TLS-encrypted. */
+export declare enum KnownProtocol {
+    /** Encrypted */
+    Encrypted = "Encrypted",
+    /** Plaintext */
+    Plaintext = "Plaintext"
+}
+/**
+ * Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Default is TLS-encrypted. \
+ * {@link KnownProtocol} can be used interchangeably with Protocol,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Encrypted**: Encrypted \
+ * **Plaintext**: Plaintext
+ */
+export type Protocol = string;
+/** Current provisioning status */
+export declare enum KnownProvisioningState {
+    /** Succeeded */
+    Succeeded = "Succeeded",
+    /** Failed */
+    Failed = "Failed",
+    /** Canceled */
+    Canceled = "Canceled",
+    /** Creating */
+    Creating = "Creating",
+    /** Updating */
+    Updating = "Updating",
+    /** Deleting */
+    Deleting = "Deleting"
+}
+/**
+ * Current provisioning status \
+ * {@link KnownProvisioningState} can be used interchangeably with ProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Succeeded**: Succeeded \
+ * **Failed**: Failed \
+ * **Canceled**: Canceled \
+ * **Creating**: Creating \
+ * **Updating**: Updating \
+ * **Deleting**: Deleting
+ */
+export type ProvisioningState = string;
+/** Current resource status */
+export declare enum KnownResourceState {
+    /** Running */
+    Running = "Running",
+    /** Creating */
+    Creating = "Creating",
+    /** CreateFailed */
+    CreateFailed = "CreateFailed",
+    /** Updating */
+    Updating = "Updating",
+    /** UpdateFailed */
+    UpdateFailed = "UpdateFailed",
+    /** Deleting */
+    Deleting = "Deleting",
+    /** DeleteFailed */
+    DeleteFailed = "DeleteFailed",
+    /** Enabling */
+    Enabling = "Enabling",
+    /** EnableFailed */
+    EnableFailed = "EnableFailed",
+    /** Disabling */
+    Disabling = "Disabling",
+    /** DisableFailed */
+    DisableFailed = "DisableFailed",
+    /** Disabled */
+    Disabled = "Disabled",
+    /** Scaling */
+    Scaling = "Scaling",
+    /** ScalingFailed */
+    ScalingFailed = "ScalingFailed",
+    /** Moving */
+    Moving = "Moving"
+}
+/**
+ * Current resource status \
+ * {@link KnownResourceState} can be used interchangeably with ResourceState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Running**: Running \
+ * **Creating**: Creating \
+ * **CreateFailed**: CreateFailed \
+ * **Updating**: Updating \
+ * **UpdateFailed**: UpdateFailed \
+ * **Deleting**: Deleting \
+ * **DeleteFailed**: DeleteFailed \
+ * **Enabling**: Enabling \
+ * **EnableFailed**: EnableFailed \
+ * **Disabling**: Disabling \
+ * **DisableFailed**: DisableFailed \
+ * **Disabled**: Disabled \
+ * **Scaling**: Scaling \
+ * **ScalingFailed**: ScalingFailed \
+ * **Moving**: Moving
+ */
+export type ResourceState = string;
+/** Clustering policy - default is OSSCluster. This property can be updated only if the current value is NoCluster. If the value is OSSCluster or EnterpriseCluster, it cannot be updated without deleting the database. */
+export declare enum KnownClusteringPolicy {
+    /** Enterprise clustering policy uses only the classic redis protocol, which does not support redis cluster commands. */
+    EnterpriseCluster = "EnterpriseCluster",
+    /** OSS clustering policy follows the redis cluster specification, and requires all clients to support redis clustering. */
+    OSSCluster = "OSSCluster",
+    /** The NoCluster policy is used for non-clustered Redis instances that do not require clustering features. */
+    NoCluster = "NoCluster"
+}
+/**
+ * Clustering policy - default is OSSCluster. This property can be updated only if the current value is NoCluster. If the value is OSSCluster or EnterpriseCluster, it cannot be updated without deleting the database. \
+ * {@link KnownClusteringPolicy} can be used interchangeably with ClusteringPolicy,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **EnterpriseCluster**: Enterprise clustering policy uses only the classic redis protocol, which does not support redis cluster commands. \
+ * **OSSCluster**: OSS clustering policy follows the redis cluster specification, and requires all clients to support redis clustering. \
+ * **NoCluster**: The NoCluster policy is used for non-clustered Redis instances that do not require clustering features.
+ */
+export type ClusteringPolicy = string;
+/** Redis eviction policy - default is VolatileLRU */
+export declare enum KnownEvictionPolicy {
+    /** AllKeysLFU */
+    AllKeysLFU = "AllKeysLFU",
+    /** AllKeysLRU */
+    AllKeysLRU = "AllKeysLRU",
+    /** AllKeysRandom */
+    AllKeysRandom = "AllKeysRandom",
+    /** VolatileLRU */
+    VolatileLRU = "VolatileLRU",
+    /** VolatileLFU */
+    VolatileLFU = "VolatileLFU",
+    /** VolatileTTL */
+    VolatileTTL = "VolatileTTL",
+    /** VolatileRandom */
+    VolatileRandom = "VolatileRandom",
+    /** NoEviction */
+    NoEviction = "NoEviction"
+}
+/**
+ * Redis eviction policy - default is VolatileLRU \
+ * {@link KnownEvictionPolicy} can be used interchangeably with EvictionPolicy,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AllKeysLFU**: AllKeysLFU \
+ * **AllKeysLRU**: AllKeysLRU \
+ * **AllKeysRandom**: AllKeysRandom \
+ * **VolatileLRU**: VolatileLRU \
+ * **VolatileLFU**: VolatileLFU \
+ * **VolatileTTL**: VolatileTTL \
+ * **VolatileRandom**: VolatileRandom \
+ * **NoEviction**: NoEviction
+ */
+export type EvictionPolicy = string;
+/** Persistence-related configuration for the Redis Enterprise database */
+export interface Persistence {
+    /** Sets whether AOF is enabled. Note that at most one of AOF or RDB persistence may be enabled. */
+    aofEnabled?: boolean;
+    /** Sets whether RDB is enabled. Note that at most one of AOF or RDB persistence may be enabled. */
+    rdbEnabled?: boolean;
+    /** Sets the frequency at which data is written to disk. Defaults to '1s', meaning 'every second'. Note that the 'always' setting is deprecated, because of its performance impact. */
+    aofFrequency?: AofFrequency;
+    /** Sets the frequency at which a snapshot of the database is created. */
+    rdbFrequency?: RdbFrequency;
+}
+export declare function persistenceSerializer(item: Persistence): any;
+export declare function persistenceDeserializer(item: any): Persistence;
+/** Sets the frequency at which data is written to disk. Defaults to '1s', meaning 'every second'. Note that the 'always' setting is deprecated, because of its performance impact. */
+export declare enum KnownAofFrequency {
+    /** 1s */
+    OneS = "1s",
+    /** always */
+    Always = "always"
+}
+/**
+ * Sets the frequency at which data is written to disk. Defaults to '1s', meaning 'every second'. Note that the 'always' setting is deprecated, because of its performance impact. \
+ * {@link KnownAofFrequency} can be used interchangeably with AofFrequency,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **1s**: 1s \
+ * **always**: always
+ */
+export type AofFrequency = string;
+/** Sets the frequency at which a snapshot of the database is created. */
+export declare enum KnownRdbFrequency {
+    /** 1h */
+    OneH = "1h",
+    /** 6h */
+    SixH = "6h",
+    /** 12h */
+    TwelveH = "12h"
+}
+/**
+ * Sets the frequency at which a snapshot of the database is created. \
+ * {@link KnownRdbFrequency} can be used interchangeably with RdbFrequency,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **1h**: 1h \
+ * **6h**: 6h \
+ * **12h**: 12h
+ */
+export type RdbFrequency = string;
+export declare function moduleArraySerializer(result: Array<Module>): any[];
+export declare function moduleArrayDeserializer(result: Array<Module>): any[];
+/** Specifies configuration of a redis module */
+export interface Module {
+    /** The name of the module, e.g. 'RedisBloom', 'RediSearch', 'RedisTimeSeries' */
+    name: string;
+    /** Configuration options for the module, e.g. 'ERROR_RATE 0.01 INITIAL_SIZE 400'. */
+    args?: string;
+    /** The version of the module, e.g. '1.0'. */
+    readonly version?: string;
+}
+export declare function moduleSerializer(item: Module): any;
+export declare function moduleDeserializer(item: any): Module;
+/** Optional set of properties to configure geo replication for this database. */
+export interface DatabaseCommonPropertiesGeoReplication {
+    /** Name for the group of linked database resources */
+    groupNickname?: string;
+    /** List of database resources to link with this database */
+    linkedDatabases?: LinkedDatabase[];
+}
+export declare function databaseCommonPropertiesGeoReplicationSerializer(item: DatabaseCommonPropertiesGeoReplication): any;
+export declare function databaseCommonPropertiesGeoReplicationDeserializer(item: any): DatabaseCommonPropertiesGeoReplication;
+export declare function linkedDatabaseArraySerializer(result: Array<LinkedDatabase>): any[];
+export declare function linkedDatabaseArrayDeserializer(result: Array<LinkedDatabase>): any[];
+/** Specifies details of a linked database resource. */
+export interface LinkedDatabase {
+    /** Resource ID of a database resource to link with this database. */
+    id?: string;
+    /** State of the link between the database resources. */
+    readonly state?: LinkState;
+}
+export declare function linkedDatabaseSerializer(item: LinkedDatabase): any;
+export declare function linkedDatabaseDeserializer(item: any): LinkedDatabase;
+/** State of the link between the database resources. */
+export declare enum KnownLinkState {
+    /** Linked */
+    Linked = "Linked",
+    /** Linking */
+    Linking = "Linking",
+    /** Unlinking */
+    Unlinking = "Unlinking",
+    /** LinkFailed */
+    LinkFailed = "LinkFailed",
+    /** UnlinkFailed */
+    UnlinkFailed = "UnlinkFailed"
+}
+/**
+ * State of the link between the database resources. \
+ * {@link KnownLinkState} can be used interchangeably with LinkState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Linked**: Linked \
+ * **Linking**: Linking \
+ * **Unlinking**: Unlinking \
+ * **LinkFailed**: LinkFailed \
+ * **UnlinkFailed**: UnlinkFailed
+ */
+export type LinkState = string;
+/** Option to defer upgrade when newest version is released - default is NotDeferred. Learn more: https://aka.ms/redisversionupgrade */
+export declare enum KnownDeferUpgradeSetting {
+    /** Deferred */
+    Deferred = "Deferred",
+    /** NotDeferred */
+    NotDeferred = "NotDeferred"
+}
+/**
+ * Option to defer upgrade when newest version is released - default is NotDeferred. Learn more: https://aka.ms/redisversionupgrade \
+ * {@link KnownDeferUpgradeSetting} can be used interchangeably with DeferUpgradeSetting,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Deferred**: Deferred \
+ * **NotDeferred**: NotDeferred
+ */
+export type DeferUpgradeSetting = string;
+/** The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location */
+export interface ProxyResource extends Resource {
+}
+export declare function proxyResourceSerializer(_item: ProxyResource): any;
+export declare function proxyResourceDeserializer(item: any): ProxyResource;
+/** Common fields that are returned in the response for all Azure Resource Manager resources */
+export interface Resource {
+    /** Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} */
+    readonly id?: string;
+    /** The name of the resource */
+    readonly name?: string;
+    /** The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts" */
+    readonly type?: string;
+    /** Azure Resource Manager metadata containing createdBy and modifiedBy information. */
+    readonly systemData?: SystemData;
+}
+export declare function resourceSerializer(_item: Resource): any;
+export declare function resourceDeserializer(item: any): Resource;
+/** Metadata pertaining to creation and last modification of the resource. */
+export interface SystemData {
+    /** The identity that created the resource. */
+    createdBy?: string;
+    /** The type of identity that created the resource. */
+    createdByType?: CreatedByType;
+    /** The timestamp of resource creation (UTC). */
+    createdAt?: Date;
+    /** The identity that last modified the resource. */
+    lastModifiedBy?: string;
+    /** The type of identity that last modified the resource. */
+    lastModifiedByType?: CreatedByType;
+    /** The timestamp of resource last modification (UTC) */
+    lastModifiedAt?: Date;
+}
+export declare function systemDataDeserializer(item: any): SystemData;
+/** The kind of entity that created the resource. */
+export declare enum KnownCreatedByType {
+    /** The entity was created by a user. */
+    User = "User",
+    /** The entity was created by an application. */
+    Application = "Application",
+    /** The entity was created by a managed identity. */
+    ManagedIdentity = "ManagedIdentity",
+    /** The entity was created by a key. */
+    Key = "Key"
+}
+/**
+ * The kind of entity that created the resource. \
+ * {@link KnownCreatedByType} can be used interchangeably with CreatedByType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **User**: The entity was created by a user. \
+ * **Application**: The entity was created by an application. \
+ * **ManagedIdentity**: The entity was created by a managed identity. \
+ * **Key**: The entity was created by a key.
+ */
+export type CreatedByType = string;
+/** A partial update to the Redis Enterprise database */
+export interface DatabaseUpdate {
+    /** Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Default is TLS-encrypted. */
+    clientProtocol?: Protocol;
+    /** TCP port of the database endpoint. Specified at create time. Defaults to an available port. */
+    port?: number;
+    /** Current provisioning status of the database */
+    readonly provisioningState?: ProvisioningState;
+    /** Current resource status of the database */
+    readonly resourceState?: ResourceState;
+    /** Clustering policy - default is OSSCluster. This property can be updated only if the current value is NoCluster. If the value is OSSCluster or EnterpriseCluster, it cannot be updated without deleting the database. */
+    clusteringPolicy?: ClusteringPolicy;
+    /** Redis eviction policy - default is VolatileLRU */
+    evictionPolicy?: EvictionPolicy;
+    /** Persistence settings */
+    persistence?: Persistence;
+    /** Optional set of redis modules to enable in this database - modules can only be added at creation time. */
+    modules?: Module[];
+    /** Optional set of properties to configure geo replication for this database. */
+    geoReplication?: DatabaseCommonPropertiesGeoReplication;
+    /** Version of Redis the database is running on, e.g. '6.0' */
+    readonly redisVersion?: string;
+    /** Option to defer upgrade when newest version is released - default is NotDeferred. Learn more: https://aka.ms/redisversionupgrade */
+    deferUpgrade?: DeferUpgradeSetting;
+    /** This property can be Enabled/Disabled to allow or deny access with the current access keys. Can be updated even after database is created. Default is Disabled. */
+    accessKeysAuthentication?: AccessKeysAuthentication;
+    /** Specifies which keyspace events should trigger notifications. Default is an empty string, meaning this feature is disabled. When enabled, at least 'K' (keyspace events) or 'E' (keyevent events) must be present. For example, 'AKE' enables all standard events. See https://redis.io/docs/latest/develop/use/keyspace-notifications/ for the complete list of event types. */
+    notifyKeyspaceEvents?: string;
+}
+export declare function databaseUpdateSerializer(item: DatabaseUpdate): any;
+/** Properties for updating Redis Enterprise databases */
+export interface DatabaseUpdateProperties extends DatabaseCommonProperties {
+    /** This property can be Enabled/Disabled to allow or deny access with the current access keys. Can be updated even after database is created. Default is Disabled. */
+    accessKeysAuthentication?: AccessKeysAuthentication;
+}
+export declare function databaseUpdatePropertiesSerializer(item: DatabaseUpdateProperties): any;
+/** The response of a list-all operation. */
+export interface _DatabaseList {
+    /** The Database items on this page */
+    value: Database[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _databaseListDeserializer(item: any): _DatabaseList;
+export declare function databaseArraySerializer(result: Array<Database>): any[];
+export declare function databaseArrayDeserializer(result: Array<Database>): any[];
+/** The secret access keys used for authenticating connections to redis */
+export interface AccessKeys {
+    /** The current primary key that clients can use to authenticate */
+    readonly primaryKey?: string;
+    /** The current secondary key that clients can use to authenticate */
+    readonly secondaryKey?: string;
+}
+export declare function accessKeysDeserializer(item: any): AccessKeys;
+/** Specifies which access keys to reset to a new random value. */
+export interface RegenerateKeyParameters {
+    /** Which access key to regenerate. */
+    keyType: AccessKeyType;
+}
+export declare function regenerateKeyParametersSerializer(item: RegenerateKeyParameters): any;
+/** Which access key to regenerate. */
+export type AccessKeyType = "Primary" | "Secondary";
+/** Parameters for a Redis Enterprise import operation. */
+export interface ImportClusterParameters {
+    /** SAS URIs for the target blobs to import from */
+    sasUris: string[];
+}
+export declare function importClusterParametersSerializer(item: ImportClusterParameters): any;
+/** Parameters for a Redis Enterprise export operation. */
+export interface ExportClusterParameters {
+    /** SAS URI for the target directory to export to */
+    sasUri: string;
+}
+export declare function exportClusterParametersSerializer(item: ExportClusterParameters): any;
+/** Parameters for a Redis Enterprise Active Geo Replication Force Unlink operation. */
+export interface ForceUnlinkParameters {
+    /** The resource IDs of the database resources to be unlinked. */
+    ids: string[];
+}
+export declare function forceUnlinkParametersSerializer(item: ForceUnlinkParameters): any;
+/** Parameters for reconfiguring active geo-replication, of an existing database that was previously unlinked from a replication group. */
+export interface ForceLinkParameters {
+    /** Properties to configure geo replication for this database. */
+    geoReplication: ForceLinkParametersGeoReplication;
+}
+export declare function forceLinkParametersSerializer(item: ForceLinkParameters): any;
+/** Properties to configure geo replication for this database. */
+export interface ForceLinkParametersGeoReplication {
+    /** The name of the group of linked database resources. This should match the existing replication group name. */
+    groupNickname?: string;
+    /** The resource IDs of the databases that are expected to be linked and included in the replication group. This parameter is used to validate that the linking is to the expected (unlinked) part of the replication group, if it is splintered. */
+    linkedDatabases?: LinkedDatabase[];
+}
+export declare function forceLinkParametersGeoReplicationSerializer(item: ForceLinkParametersGeoReplication): any;
+/** Parameters for a Redis Enterprise active geo-replication flush operation */
+export interface FlushParameters {
+    /** The identifiers of all the other database resources in the georeplication group to be flushed. */
+    ids?: string[];
+}
+export declare function flushParametersSerializer(item: FlushParameters): any;
+/** The Private Endpoint Connection resource. */
+export interface PrivateEndpointConnection extends Resource {
+    /** The group ids for the private endpoint resource. */
+    readonly groupIds?: string[];
+    /** The private endpoint resource. */
+    privateEndpoint?: PrivateEndpoint;
+    /** A collection of information about the state of the connection between service consumer and provider. */
+    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
+    /** The provisioning state of the private endpoint connection resource. */
+    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
+}
+export declare function privateEndpointConnectionSerializer(item: PrivateEndpointConnection): any;
+export declare function privateEndpointConnectionDeserializer(item: any): PrivateEndpointConnection;
+/** Properties of the private endpoint connection. */
+export interface PrivateEndpointConnectionProperties {
+    /** The group ids for the private endpoint resource. */
+    readonly groupIds?: string[];
+    /** The private endpoint resource. */
+    privateEndpoint?: PrivateEndpoint;
+    /** A collection of information about the state of the connection between service consumer and provider. */
+    privateLinkServiceConnectionState: PrivateLinkServiceConnectionState;
+    /** The provisioning state of the private endpoint connection resource. */
+    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
+}
+export declare function privateEndpointConnectionPropertiesSerializer(item: PrivateEndpointConnectionProperties): any;
+export declare function privateEndpointConnectionPropertiesDeserializer(item: any): PrivateEndpointConnectionProperties;
+/** The private endpoint resource. */
+export interface PrivateEndpoint {
+    /** The resource identifier of the private endpoint */
+    readonly id?: string;
+}
+export declare function privateEndpointSerializer(_item: PrivateEndpoint): any;
+export declare function privateEndpointDeserializer(item: any): PrivateEndpoint;
+/** A collection of information about the state of the connection between service consumer and provider. */
+export interface PrivateLinkServiceConnectionState {
+    /** Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service. */
+    status?: PrivateEndpointServiceConnectionStatus;
+    /** The reason for approval/rejection of the connection. */
+    description?: string;
+    /** A message indicating if changes on the service provider require any updates on the consumer. */
+    actionsRequired?: string;
+}
+export declare function privateLinkServiceConnectionStateSerializer(item: PrivateLinkServiceConnectionState): any;
+export declare function privateLinkServiceConnectionStateDeserializer(item: any): PrivateLinkServiceConnectionState;
+/** The private endpoint connection status. */
+export declare enum KnownPrivateEndpointServiceConnectionStatus {
+    /** Connection waiting for approval or rejection */
+    Pending = "Pending",
+    /** Connection approved */
+    Approved = "Approved",
+    /** Connection Rejected */
+    Rejected = "Rejected"
+}
+/**
+ * The private endpoint connection status. \
+ * {@link KnownPrivateEndpointServiceConnectionStatus} can be used interchangeably with PrivateEndpointServiceConnectionStatus,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Pending**: Connection waiting for approval or rejection \
+ * **Approved**: Connection approved \
+ * **Rejected**: Connection Rejected
+ */
+export type PrivateEndpointServiceConnectionStatus = string;
+/** The current provisioning state. */
+export declare enum KnownPrivateEndpointConnectionProvisioningState {
+    /** Connection has been provisioned */
+    Succeeded = "Succeeded",
+    /** Connection is being created */
+    Creating = "Creating",
+    /** Connection is being deleted */
+    Deleting = "Deleting",
+    /** Connection provisioning has failed */
+    Failed = "Failed"
+}
+/**
+ * The current provisioning state. \
+ * {@link KnownPrivateEndpointConnectionProvisioningState} can be used interchangeably with PrivateEndpointConnectionProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Succeeded**: Connection has been provisioned \
+ * **Creating**: Connection is being created \
+ * **Deleting**: Connection is being deleted \
+ * **Failed**: Connection provisioning has failed
+ */
+export type PrivateEndpointConnectionProvisioningState = string;
+/** The response of a PrivateEndpointConnection list operation. */
+export interface _PrivateEndpointConnectionListResult {
+    /** The PrivateEndpointConnection items on this page */
+    value: PrivateEndpointConnection[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _privateEndpointConnectionListResultDeserializer(item: any): _PrivateEndpointConnectionListResult;
+export declare function privateEndpointConnectionArraySerializer(result: Array<PrivateEndpointConnection>): any[];
+export declare function privateEndpointConnectionArrayDeserializer(result: Array<PrivateEndpointConnection>): any[];
+/** Properties for validating migration from Azure Cache for Redis to Redis Enterprise. */
+export interface MigrationValidationRequest {
+    /** The source resource ID to validate migration from. This is the resource ID of the Azure Cache for Redis. */
+    sourceResourceId: string;
+    /** Sets whether the data is migrated from source to target or not. The default value is true. */
+    skipDataMigration?: boolean;
+    /** Sets whether to ignore warnings when validating if the source cache can be migrated to the target cache. If this property is true, the isValid property in the response will ignore warning-level disparities between the source and target resource. The default value is false. */
+    forceMigrate?: boolean;
+}
+export declare function migrationValidationRequestSerializer(item: MigrationValidationRequest): any;
+/** Response for migration validation operation. */
+export interface MigrationValidationResponse {
+    /** Indicates whether the migration validation passed. */
+    isValid: boolean;
+    /** List of validation errors that prevent migration. */
+    errors?: MigrationValidationError[];
+    /** List of validation warnings that may impact migration. */
+    warnings?: MigrationValidationWarning[];
+}
+export declare function migrationValidationResponseDeserializer(item: any): MigrationValidationResponse;
+export declare function migrationValidationErrorArrayDeserializer(result: Array<MigrationValidationError>): any[];
+/** Represents a validation error that prevents migration. */
+export interface MigrationValidationError {
+    /** List of specific disparities that cause this error. */
+    disparities: MigrationValidationDisparity[];
+}
+export declare function migrationValidationErrorDeserializer(item: any): MigrationValidationError;
+export declare function migrationValidationDisparityArrayDeserializer(result: Array<MigrationValidationDisparity>): any[];
+/** Represents a specific validation issue found during migration validation. */
+export interface MigrationValidationDisparity {
+    /** A localized string denoting the category of the validation issue. Examples are "Region", "Data", "Identity", "Clustering Mode", and "TLS". */
+    category: string;
+    /** Detailed message describing the validation issue. */
+    message: string;
+}
+export declare function migrationValidationDisparityDeserializer(item: any): MigrationValidationDisparity;
+export declare function migrationValidationWarningArrayDeserializer(result: Array<MigrationValidationWarning>): any[];
+/** Represents a validation warning that may impact migration. */
+export interface MigrationValidationWarning {
+    /** List of specific disparities that cause this warning. */
+    disparities: MigrationValidationDisparity[];
+}
+export declare function migrationValidationWarningDeserializer(item: any): MigrationValidationWarning;
+/** Describes the Redis Enterprise cluster */
+export interface Cluster extends TrackedResource {
+    /** Distinguishes the kind of cluster. Read-only. */
+    readonly kind?: Kind;
+    /** The SKU to create, which affects price, performance, and features. */
+    sku: Sku;
+    /** The availability zones. */
+    zones?: string[];
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+    /** Enabled by default. If highAvailability is disabled, the data set is not replicated. This affects the availability SLA, and increases the risk of data loss. */
+    highAvailability?: HighAvailability;
+    /** The minimum TLS version for the cluster to support, e.g. '1.2'. Newer versions can be added in the future. Note that TLS 1.0 and TLS 1.1 are now completely obsolete -- you cannot use them. They are mentioned only for the sake of consistency with old API versions. */
+    minimumTlsVersion?: TlsVersion;
+    /** Encryption-at-rest configuration for the cluster. */
+    encryption?: ClusterCommonPropertiesEncryption;
+    /** Cluster-level maintenance configuration. */
+    maintenanceConfiguration?: MaintenanceConfiguration;
+    /** DNS name of the cluster endpoint */
+    readonly hostName?: string;
+    /** Current provisioning status of the cluster */
+    readonly provisioningState?: ProvisioningState;
+    /** Explains the current redundancy strategy of the cluster, which affects the expected SLA. */
+    readonly redundancyMode?: RedundancyMode;
+    /** Current resource status of the cluster */
+    readonly resourceState?: ResourceState;
+    /** Version of redis the cluster supports, e.g. '6' */
+    readonly redisVersion?: string;
+    /** List of private endpoint connections associated with the specified Redis Enterprise cluster */
+    readonly privateEndpointConnections?: PrivateEndpointConnection[];
+    /** The endpoint of the source resource that is currently pointing to this resource as a result of an ACR/ACRE to AMR migration. */
+    readonly migratedEndpoint?: string;
+    /** Whether or not public network traffic can access the Redis cluster. Only 'Enabled' or 'Disabled' can be set. null is returned only for clusters created using an old API version which do not have this property and cannot be set. */
+    publicNetworkAccess?: PublicNetworkAccess;
+}
+export declare function clusterSerializer(item: Cluster): any;
+export declare function clusterDeserializer(item: any): Cluster;
+/** Properties of Redis Enterprise clusters for create operations */
+export interface ClusterCreateProperties extends ClusterCommonProperties {
+    /** Whether or not public network traffic can access the Redis cluster. Only 'Enabled' or 'Disabled' can be set. null is returned only for clusters created using an old API version which do not have this property and cannot be set. */
+    publicNetworkAccess: PublicNetworkAccess | null;
+}
+export declare function clusterCreatePropertiesSerializer(item: ClusterCreateProperties): any;
+export declare function clusterCreatePropertiesDeserializer(item: any): ClusterCreateProperties;
+/** Whether or not public network traffic can access the Redis cluster. Only 'Enabled' or 'Disabled' can be set. null is returned only for clusters created using an old API version which do not have this property and cannot be set. */
+export declare enum KnownPublicNetworkAccess {
+    /** Enabled */
+    Enabled = "Enabled",
+    /** Disabled */
+    Disabled = "Disabled"
+}
+/**
+ * Whether or not public network traffic can access the Redis cluster. Only 'Enabled' or 'Disabled' can be set. null is returned only for clusters created using an old API version which do not have this property and cannot be set. \
+ * {@link KnownPublicNetworkAccess} can be used interchangeably with PublicNetworkAccess,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Enabled \
+ * **Disabled**: Disabled
+ */
+export type PublicNetworkAccess = string;
+/** Distinguishes the kind of cluster. Read-only. */
+export declare enum KnownKind {
+    /** v1 */
+    V1 = "v1",
+    /** v2 */
+    V2 = "v2"
+}
+/**
+ * Distinguishes the kind of cluster. Read-only. \
+ * {@link KnownKind} can be used interchangeably with Kind,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **v1**: v1 \
+ * **v2**: v2
+ */
+export type Kind = string;
+/** SKU parameters supplied to the create Redis Enterprise cluster operation. */
+export interface Sku {
+    /** The level of Redis Enterprise cluster to deploy. Possible values: ('Balanced_B5', 'MemoryOptimized_M10', 'ComputeOptimized_X5', etc.). For more information on SKUs see the latest pricing documentation. Note that additional SKUs may become supported in the future. */
+    name: SkuName;
+    /** This property is only used with Enterprise and EnterpriseFlash SKUs. Determines the size of the cluster. Valid values are (2, 4, 6, ...) for Enterprise SKUs and (3, 9, 15, ...) for EnterpriseFlash SKUs. */
+    capacity?: number;
+}
+export declare function skuSerializer(item: Sku): any;
+export declare function skuDeserializer(item: any): Sku;
+/** The level of Redis Enterprise cluster to deploy. Possible values: ('Balanced_B5', 'MemoryOptimized_M10', 'ComputeOptimized_X5', etc.). For more information on SKUs see the latest pricing documentation. Note that additional SKUs may become supported in the future. */
+export declare enum KnownSkuName {
+    /** Enterprise_E1 */
+    EnterpriseE1 = "Enterprise_E1",
+    /** Enterprise_E5 */
+    EnterpriseE5 = "Enterprise_E5",
+    /** Enterprise_E10 */
+    EnterpriseE10 = "Enterprise_E10",
+    /** Enterprise_E20 */
+    EnterpriseE20 = "Enterprise_E20",
+    /** Enterprise_E50 */
+    EnterpriseE50 = "Enterprise_E50",
+    /** Enterprise_E100 */
+    EnterpriseE100 = "Enterprise_E100",
+    /** Enterprise_E200 */
+    EnterpriseE200 = "Enterprise_E200",
+    /** Enterprise_E400 */
+    EnterpriseE400 = "Enterprise_E400",
+    /** EnterpriseFlash_F300 */
+    EnterpriseFlashF300 = "EnterpriseFlash_F300",
+    /** EnterpriseFlash_F700 */
+    EnterpriseFlashF700 = "EnterpriseFlash_F700",
+    /** EnterpriseFlash_F1500 */
+    EnterpriseFlashF1500 = "EnterpriseFlash_F1500",
+    /** Balanced_B0 */
+    BalancedB0 = "Balanced_B0",
+    /** Balanced_B1 */
+    BalancedB1 = "Balanced_B1",
+    /** Balanced_B3 */
+    BalancedB3 = "Balanced_B3",
+    /** Balanced_B5 */
+    BalancedB5 = "Balanced_B5",
+    /** Balanced_B10 */
+    BalancedB10 = "Balanced_B10",
+    /** Balanced_B20 */
+    BalancedB20 = "Balanced_B20",
+    /** Balanced_B50 */
+    BalancedB50 = "Balanced_B50",
+    /** Balanced_B100 */
+    BalancedB100 = "Balanced_B100",
+    /** Balanced_B150 */
+    BalancedB150 = "Balanced_B150",
+    /** Balanced_B250 */
+    BalancedB250 = "Balanced_B250",
+    /** Balanced_B350 */
+    BalancedB350 = "Balanced_B350",
+    /** Balanced_B500 */
+    BalancedB500 = "Balanced_B500",
+    /** Balanced_B700 */
+    BalancedB700 = "Balanced_B700",
+    /** Balanced_B1000 */
+    BalancedB1000 = "Balanced_B1000",
+    /** MemoryOptimized_M10 */
+    MemoryOptimizedM10 = "MemoryOptimized_M10",
+    /** MemoryOptimized_M20 */
+    MemoryOptimizedM20 = "MemoryOptimized_M20",
+    /** MemoryOptimized_M50 */
+    MemoryOptimizedM50 = "MemoryOptimized_M50",
+    /** MemoryOptimized_M100 */
+    MemoryOptimizedM100 = "MemoryOptimized_M100",
+    /** MemoryOptimized_M150 */
+    MemoryOptimizedM150 = "MemoryOptimized_M150",
+    /** MemoryOptimized_M250 */
+    MemoryOptimizedM250 = "MemoryOptimized_M250",
+    /** MemoryOptimized_M350 */
+    MemoryOptimizedM350 = "MemoryOptimized_M350",
+    /** MemoryOptimized_M500 */
+    MemoryOptimizedM500 = "MemoryOptimized_M500",
+    /** MemoryOptimized_M700 */
+    MemoryOptimizedM700 = "MemoryOptimized_M700",
+    /** MemoryOptimized_M1000 */
+    MemoryOptimizedM1000 = "MemoryOptimized_M1000",
+    /** MemoryOptimized_M1500 */
+    MemoryOptimizedM1500 = "MemoryOptimized_M1500",
+    /** MemoryOptimized_M2000 */
+    MemoryOptimizedM2000 = "MemoryOptimized_M2000",
+    /** ComputeOptimized_X3 */
+    ComputeOptimizedX3 = "ComputeOptimized_X3",
+    /** ComputeOptimized_X5 */
+    ComputeOptimizedX5 = "ComputeOptimized_X5",
+    /** ComputeOptimized_X10 */
+    ComputeOptimizedX10 = "ComputeOptimized_X10",
+    /** ComputeOptimized_X20 */
+    ComputeOptimizedX20 = "ComputeOptimized_X20",
+    /** ComputeOptimized_X50 */
+    ComputeOptimizedX50 = "ComputeOptimized_X50",
+    /** ComputeOptimized_X100 */
+    ComputeOptimizedX100 = "ComputeOptimized_X100",
+    /** ComputeOptimized_X150 */
+    ComputeOptimizedX150 = "ComputeOptimized_X150",
+    /** ComputeOptimized_X250 */
+    ComputeOptimizedX250 = "ComputeOptimized_X250",
+    /** ComputeOptimized_X350 */
+    ComputeOptimizedX350 = "ComputeOptimized_X350",
+    /** ComputeOptimized_X500 */
+    ComputeOptimizedX500 = "ComputeOptimized_X500",
+    /** ComputeOptimized_X700 */
+    ComputeOptimizedX700 = "ComputeOptimized_X700",
+    /** FlashOptimized_A250 */
+    FlashOptimizedA250 = "FlashOptimized_A250",
+    /** FlashOptimized_A500 */
+    FlashOptimizedA500 = "FlashOptimized_A500",
+    /** FlashOptimized_A700 */
+    FlashOptimizedA700 = "FlashOptimized_A700",
+    /** FlashOptimized_A1000 */
+    FlashOptimizedA1000 = "FlashOptimized_A1000",
+    /** FlashOptimized_A1500 */
+    FlashOptimizedA1500 = "FlashOptimized_A1500",
+    /** FlashOptimized_A2000 */
+    FlashOptimizedA2000 = "FlashOptimized_A2000",
+    /** FlashOptimized_A4500 */
+    FlashOptimizedA4500 = "FlashOptimized_A4500"
+}
+/**
+ * The level of Redis Enterprise cluster to deploy. Possible values: ('Balanced_B5', 'MemoryOptimized_M10', 'ComputeOptimized_X5', etc.). For more information on SKUs see the latest pricing documentation. Note that additional SKUs may become supported in the future. \
+ * {@link KnownSkuName} can be used interchangeably with SkuName,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enterprise_E1**: Enterprise_E1 \
+ * **Enterprise_E5**: Enterprise_E5 \
+ * **Enterprise_E10**: Enterprise_E10 \
+ * **Enterprise_E20**: Enterprise_E20 \
+ * **Enterprise_E50**: Enterprise_E50 \
+ * **Enterprise_E100**: Enterprise_E100 \
+ * **Enterprise_E200**: Enterprise_E200 \
+ * **Enterprise_E400**: Enterprise_E400 \
+ * **EnterpriseFlash_F300**: EnterpriseFlash_F300 \
+ * **EnterpriseFlash_F700**: EnterpriseFlash_F700 \
+ * **EnterpriseFlash_F1500**: EnterpriseFlash_F1500 \
+ * **Balanced_B0**: Balanced_B0 \
+ * **Balanced_B1**: Balanced_B1 \
+ * **Balanced_B3**: Balanced_B3 \
+ * **Balanced_B5**: Balanced_B5 \
+ * **Balanced_B10**: Balanced_B10 \
+ * **Balanced_B20**: Balanced_B20 \
+ * **Balanced_B50**: Balanced_B50 \
+ * **Balanced_B100**: Balanced_B100 \
+ * **Balanced_B150**: Balanced_B150 \
+ * **Balanced_B250**: Balanced_B250 \
+ * **Balanced_B350**: Balanced_B350 \
+ * **Balanced_B500**: Balanced_B500 \
+ * **Balanced_B700**: Balanced_B700 \
+ * **Balanced_B1000**: Balanced_B1000 \
+ * **MemoryOptimized_M10**: MemoryOptimized_M10 \
+ * **MemoryOptimized_M20**: MemoryOptimized_M20 \
+ * **MemoryOptimized_M50**: MemoryOptimized_M50 \
+ * **MemoryOptimized_M100**: MemoryOptimized_M100 \
+ * **MemoryOptimized_M150**: MemoryOptimized_M150 \
+ * **MemoryOptimized_M250**: MemoryOptimized_M250 \
+ * **MemoryOptimized_M350**: MemoryOptimized_M350 \
+ * **MemoryOptimized_M500**: MemoryOptimized_M500 \
+ * **MemoryOptimized_M700**: MemoryOptimized_M700 \
+ * **MemoryOptimized_M1000**: MemoryOptimized_M1000 \
+ * **MemoryOptimized_M1500**: MemoryOptimized_M1500 \
+ * **MemoryOptimized_M2000**: MemoryOptimized_M2000 \
+ * **ComputeOptimized_X3**: ComputeOptimized_X3 \
+ * **ComputeOptimized_X5**: ComputeOptimized_X5 \
+ * **ComputeOptimized_X10**: ComputeOptimized_X10 \
+ * **ComputeOptimized_X20**: ComputeOptimized_X20 \
+ * **ComputeOptimized_X50**: ComputeOptimized_X50 \
+ * **ComputeOptimized_X100**: ComputeOptimized_X100 \
+ * **ComputeOptimized_X150**: ComputeOptimized_X150 \
+ * **ComputeOptimized_X250**: ComputeOptimized_X250 \
+ * **ComputeOptimized_X350**: ComputeOptimized_X350 \
+ * **ComputeOptimized_X500**: ComputeOptimized_X500 \
+ * **ComputeOptimized_X700**: ComputeOptimized_X700 \
+ * **FlashOptimized_A250**: FlashOptimized_A250 \
+ * **FlashOptimized_A500**: FlashOptimized_A500 \
+ * **FlashOptimized_A700**: FlashOptimized_A700 \
+ * **FlashOptimized_A1000**: FlashOptimized_A1000 \
+ * **FlashOptimized_A1500**: FlashOptimized_A1500 \
+ * **FlashOptimized_A2000**: FlashOptimized_A2000 \
+ * **FlashOptimized_A4500**: FlashOptimized_A4500
+ */
+export type SkuName = 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>;
+}
+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;
+export declare function userAssignedIdentityRecordSerializer(item: Record<string, UserAssignedIdentity>): Record<string, any>;
+export declare function userAssignedIdentityRecordDeserializer(item: Record<string, any>): Record<string, UserAssignedIdentity>;
+/** 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;
+/** Properties of Redis Enterprise clusters, as opposed to general resource properties like location, tags */
+export interface ClusterCommonProperties {
+    /** Enabled by default. If highAvailability is disabled, the data set is not replicated. This affects the availability SLA, and increases the risk of data loss. */
+    highAvailability?: HighAvailability;
+    /** The minimum TLS version for the cluster to support, e.g. '1.2'. Newer versions can be added in the future. Note that TLS 1.0 and TLS 1.1 are now completely obsolete -- you cannot use them. They are mentioned only for the sake of consistency with old API versions. */
+    minimumTlsVersion?: TlsVersion;
+    /** Encryption-at-rest configuration for the cluster. */
+    encryption?: ClusterCommonPropertiesEncryption;
+    /** Cluster-level maintenance configuration. */
+    maintenanceConfiguration?: MaintenanceConfiguration;
+    /** DNS name of the cluster endpoint */
+    readonly hostName?: string;
+    /** Current provisioning status of the cluster */
+    readonly provisioningState?: ProvisioningState;
+    /** Explains the current redundancy strategy of the cluster, which affects the expected SLA. */
+    readonly redundancyMode?: RedundancyMode;
+    /** Current resource status of the cluster */
+    readonly resourceState?: ResourceState;
+    /** Version of redis the cluster supports, e.g. '6' */
+    readonly redisVersion?: string;
+    /** List of private endpoint connections associated with the specified Redis Enterprise cluster */
+    readonly privateEndpointConnections?: PrivateEndpointConnection[];
+    /** The endpoint of the source resource that is currently pointing to this resource as a result of an ACR/ACRE to AMR migration. */
+    readonly migratedEndpoint?: string;
+}
+export declare function clusterCommonPropertiesSerializer(item: ClusterCommonProperties): any;
+export declare function clusterCommonPropertiesDeserializer(item: any): ClusterCommonProperties;
+/** Enabled by default. If highAvailability is disabled, the data set is not replicated. This affects the availability SLA, and increases the risk of data loss. */
+export declare enum KnownHighAvailability {
+    /** Enabled */
+    Enabled = "Enabled",
+    /** Disabled */
+    Disabled = "Disabled"
+}
+/**
+ * Enabled by default. If highAvailability is disabled, the data set is not replicated. This affects the availability SLA, and increases the risk of data loss. \
+ * {@link KnownHighAvailability} can be used interchangeably with HighAvailability,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Enabled**: Enabled \
+ * **Disabled**: Disabled
+ */
+export type HighAvailability = string;
+/** The minimum TLS version for the cluster to support, e.g. '1.2'. Newer versions can be added in the future. Note that TLS 1.0 and TLS 1.1 are now completely obsolete -- you cannot use them. They are mentioned only for the sake of consistency with old API versions. */
+export declare enum KnownTlsVersion {
+    /** 1.0 */
+    One0 = "1.0",
+    /** 1.1 */
+    One1 = "1.1",
+    /** 1.2 */
+    One2 = "1.2"
+}
+/**
+ * The minimum TLS version for the cluster to support, e.g. '1.2'. Newer versions can be added in the future. Note that TLS 1.0 and TLS 1.1 are now completely obsolete -- you cannot use them. They are mentioned only for the sake of consistency with old API versions. \
+ * {@link KnownTlsVersion} can be used interchangeably with TlsVersion,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **1.0**: 1.0 \
+ * **1.1**: 1.1 \
+ * **1.2**: 1.2
+ */
+export type TlsVersion = string;
+/** Encryption-at-rest configuration for the cluster. */
+export interface ClusterCommonPropertiesEncryption {
+    /** All Customer-managed key encryption properties for the resource. Set this to an empty object to use Microsoft-managed key encryption. */
+    customerManagedKeyEncryption?: ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryption;
+}
+export declare function clusterCommonPropertiesEncryptionSerializer(item: ClusterCommonPropertiesEncryption): any;
+export declare function clusterCommonPropertiesEncryptionDeserializer(item: any): ClusterCommonPropertiesEncryption;
+/** All Customer-managed key encryption properties for the resource. Set this to an empty object to use Microsoft-managed key encryption. */
+export interface ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryption {
+    /** All identity configuration for Customer-managed key settings defining which identity should be used to auth to Key Vault. */
+    keyEncryptionKeyIdentity?: ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentity;
+    /** Key encryption key Url, versioned only. Ex: https://contosovault.vault.azure.net/keys/contosokek/562a4bb76b524a1493a6afe8e536ee78 */
+    keyEncryptionKeyUrl?: string;
+}
+export declare function clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionSerializer(item: ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryption): any;
+export declare function clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionDeserializer(item: any): ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryption;
+/** All identity configuration for Customer-managed key settings defining which identity should be used to auth to Key Vault. */
+export interface ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentity {
+    /** User assigned identity to use for accessing key encryption key Url. Ex: /subscriptions/<sub uuid>/resourceGroups/<resource group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId. */
+    userAssignedIdentityResourceId?: string;
+    /** Only userAssignedIdentity is supported in this API version; other types may be supported in the future */
+    identityType?: CmkIdentityType;
+}
+export declare function clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentitySerializer(item: ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentity): any;
+export declare function clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentityDeserializer(item: any): ClusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentity;
+/** Only userAssignedIdentity is supported in this API version; other types may be supported in the future */
+export declare enum KnownCmkIdentityType {
+    /** systemAssignedIdentity */
+    SystemAssignedIdentity = "systemAssignedIdentity",
+    /** userAssignedIdentity */
+    UserAssignedIdentity = "userAssignedIdentity"
+}
+/**
+ * Only userAssignedIdentity is supported in this API version; other types may be supported in the future \
+ * {@link KnownCmkIdentityType} can be used interchangeably with CmkIdentityType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **systemAssignedIdentity**: systemAssignedIdentity \
+ * **userAssignedIdentity**: userAssignedIdentity
+ */
+export type CmkIdentityType = string;
+/** Cluster-level maintenance configuration. */
+export interface MaintenanceConfiguration {
+    /** Custom maintenance windows that apply to the cluster. */
+    maintenanceWindows?: MaintenanceWindow[];
+}
+export declare function maintenanceConfigurationSerializer(item: MaintenanceConfiguration): any;
+export declare function maintenanceConfigurationDeserializer(item: any): MaintenanceConfiguration;
+export declare function maintenanceWindowArraySerializer(result: Array<MaintenanceWindow>): any[];
+export declare function maintenanceWindowArrayDeserializer(result: Array<MaintenanceWindow>): any[];
+/** A single custom maintenance window. */
+export interface MaintenanceWindow {
+    /** Maintenance window type. */
+    type: MaintenanceWindowType;
+    /** Duration in ISO-8601 format, for example 'PT5H'. */
+    duration: string;
+    /** Start hour (0-23) in UTC when the maintenance window begins. */
+    startHourUtc: number;
+    /** Recurring schedule for the maintenance window. */
+    schedule: MaintenanceWindowSchedule;
+}
+export declare function maintenanceWindowSerializer(item: MaintenanceWindow): any;
+export declare function maintenanceWindowDeserializer(item: any): MaintenanceWindow;
+/** Maintenance window type. */
+export declare enum KnownMaintenanceWindowType {
+    /** Weekly maintenance window. */
+    Weekly = "Weekly"
+}
+/**
+ * Maintenance window type. \
+ * {@link KnownMaintenanceWindowType} can be used interchangeably with MaintenanceWindowType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Weekly**: Weekly maintenance window.
+ */
+export type MaintenanceWindowType = string;
+/** Schedule details for a maintenance window. */
+export interface MaintenanceWindowSchedule {
+    /** Day of week. Required when the maintenance window type is 'Weekly'. */
+    dayOfWeek?: MaintenanceDayOfWeek;
+}
+export declare function maintenanceWindowScheduleSerializer(item: MaintenanceWindowSchedule): any;
+export declare function maintenanceWindowScheduleDeserializer(item: any): MaintenanceWindowSchedule;
+/** Day of week. Required when the maintenance window type is 'Weekly'. */
+export declare enum KnownMaintenanceDayOfWeek {
+    /** Sunday */
+    Sunday = "Sunday",
+    /** Monday */
+    Monday = "Monday",
+    /** Tuesday */
+    Tuesday = "Tuesday",
+    /** Wednesday */
+    Wednesday = "Wednesday",
+    /** Thursday */
+    Thursday = "Thursday",
+    /** Friday */
+    Friday = "Friday",
+    /** Saturday */
+    Saturday = "Saturday"
+}
+/**
+ * Day of week. Required when the maintenance window type is 'Weekly'. \
+ * {@link KnownMaintenanceDayOfWeek} can be used interchangeably with MaintenanceDayOfWeek,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Sunday** \
+ * **Monday** \
+ * **Tuesday** \
+ * **Wednesday** \
+ * **Thursday** \
+ * **Friday** \
+ * **Saturday**
+ */
+export type MaintenanceDayOfWeek = string;
+/** Explains the current redundancy strategy of the cluster, which affects the expected SLA. */
+export declare enum KnownRedundancyMode {
+    /** No redundancy. Availability loss will occur. */
+    None = "None",
+    /** Local redundancy with high availability. */
+    LR = "LR",
+    /** Zone redundant. Higher availability. */
+    ZR = "ZR"
+}
+/**
+ * Explains the current redundancy strategy of the cluster, which affects the expected SLA. \
+ * {@link KnownRedundancyMode} can be used interchangeably with RedundancyMode,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **None**: No redundancy. Availability loss will occur. \
+ * **LR**: Local redundancy with high availability. \
+ * **ZR**: Zone redundant. Higher availability.
+ */
+export type RedundancyMode = string;
+/** The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location' */
+export interface TrackedResource extends Resource {
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** The geo-location where the resource lives */
+    location: string;
+}
+export declare function trackedResourceSerializer(item: TrackedResource): any;
+export declare function trackedResourceDeserializer(item: any): TrackedResource;
+/** A partial update to the Redis Enterprise cluster */
+export interface ClusterUpdate {
+    /** The SKU to create, which affects price, performance, and features. */
+    sku?: Sku;
+    /** The managed service identities assigned to this resource. */
+    identity?: ManagedServiceIdentity;
+    /** Resource tags. */
+    tags?: Record<string, string>;
+    /** Enabled by default. If highAvailability is disabled, the data set is not replicated. This affects the availability SLA, and increases the risk of data loss. */
+    highAvailability?: HighAvailability;
+    /** The minimum TLS version for the cluster to support, e.g. '1.2'. Newer versions can be added in the future. Note that TLS 1.0 and TLS 1.1 are now completely obsolete -- you cannot use them. They are mentioned only for the sake of consistency with old API versions. */
+    minimumTlsVersion?: TlsVersion;
+    /** Encryption-at-rest configuration for the cluster. */
+    encryption?: ClusterCommonPropertiesEncryption;
+    /** Cluster-level maintenance configuration. */
+    maintenanceConfiguration?: MaintenanceConfiguration;
+    /** DNS name of the cluster endpoint */
+    readonly hostName?: string;
+    /** Current provisioning status of the cluster */
+    readonly provisioningState?: ProvisioningState;
+    /** Explains the current redundancy strategy of the cluster, which affects the expected SLA. */
+    readonly redundancyMode?: RedundancyMode;
+    /** Current resource status of the cluster */
+    readonly resourceState?: ResourceState;
+    /** Version of redis the cluster supports, e.g. '6' */
+    readonly redisVersion?: string;
+    /** List of private endpoint connections associated with the specified Redis Enterprise cluster */
+    readonly privateEndpointConnections?: PrivateEndpointConnection[];
+    /** The endpoint of the source resource that is currently pointing to this resource as a result of an ACR/ACRE to AMR migration. */
+    readonly migratedEndpoint?: string;
+    /** Whether or not public network traffic can access the Redis cluster. Only 'Enabled' or 'Disabled' can be set. null is returned only for clusters created using an old API version which do not have this property and cannot be set. */
+    publicNetworkAccess?: PublicNetworkAccess;
+}
+export declare function clusterUpdateSerializer(item: ClusterUpdate): any;
+/** Properties of Redis Enterprise clusters for update operations */
+export interface ClusterUpdateProperties extends ClusterCommonProperties {
+    /** Whether or not public network traffic can access the Redis cluster. Only 'Enabled' or 'Disabled' can be set. null is returned only for clusters created using an old API version which do not have this property and cannot be set. */
+    publicNetworkAccess?: PublicNetworkAccess;
+}
+export declare function clusterUpdatePropertiesSerializer(item: ClusterUpdateProperties): any;
+/** The response of a list-all operation. */
+export interface _ClusterList {
+    /** The Cluster items on this page */
+    value: Cluster[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _clusterListDeserializer(item: any): _ClusterList;
+export declare function clusterArraySerializer(result: Array<Cluster>): any[];
+export declare function clusterArrayDeserializer(result: Array<Cluster>): any[];
+/** The response of a listSkusForScaling operation. */
+export interface SkuDetailsList {
+    /** List of SKUS available to scale up or scale down. */
+    skus?: SkuDetails[];
+}
+export declare function skuDetailsListDeserializer(item: any): SkuDetailsList;
+export declare function skuDetailsArrayDeserializer(result: Array<SkuDetails>): any[];
+/** Details of a Redis Enterprise cluster SKU. */
+export interface SkuDetails {
+    /** The name of the SKU. */
+    readonly name?: string;
+    /** The cache size in GB. */
+    readonly sizeInGB?: number;
+}
+export declare function skuDetailsDeserializer(item: any): SkuDetails;
+/** A list of private link resources. */
+export interface _PrivateLinkResourceListResult {
+    /** Array of private link resources */
+    value?: PrivateLinkResource[];
+    /** URL to get the next set of operation list results (if there are any). */
+    readonly nextLink?: string;
+}
+export declare function _privateLinkResourceListResultDeserializer(item: any): _PrivateLinkResourceListResult;
+export declare function privateLinkResourceArrayDeserializer(result: Array<PrivateLinkResource>): any[];
+/** A private link resource. */
+export interface PrivateLinkResource extends Resource {
+    /** The private link resource group id. */
+    readonly groupId?: string;
+    /** The private link resource required member names. */
+    readonly requiredMembers?: string[];
+    /** The private link resource private link DNS zone name. */
+    requiredZoneNames?: string[];
+}
+export declare function privateLinkResourceDeserializer(item: any): PrivateLinkResource;
+/** Properties of a private link resource. */
+export interface PrivateLinkResourceProperties {
+    /** The private link resource group id. */
+    readonly groupId?: string;
+    /** The private link resource required member names. */
+    readonly requiredMembers?: string[];
+    /** The private link resource private link DNS zone name. */
+    requiredZoneNames?: string[];
+}
+export declare function privateLinkResourcePropertiesDeserializer(item: any): PrivateLinkResourceProperties;
+/** Describes the access policy assignment of Redis Enterprise database */
+export interface AccessPolicyAssignment extends ProxyResource {
+    /** Current provisioning status of the access policy assignment. */
+    readonly provisioningState?: ProvisioningState;
+    /** Name of access policy under specific access policy assignment. Only "default" policy is supported for now. */
+    accessPolicyName?: string;
+    /** The user associated with the access policy. */
+    user?: AccessPolicyAssignmentPropertiesUser;
+}
+export declare function accessPolicyAssignmentSerializer(item: AccessPolicyAssignment): any;
+export declare function accessPolicyAssignmentDeserializer(item: any): AccessPolicyAssignment;
+/** Properties of Redis Enterprise database access policy assignment. */
+export interface AccessPolicyAssignmentProperties {
+    /** Current provisioning status of the access policy assignment. */
+    readonly provisioningState?: ProvisioningState;
+    /** Name of access policy under specific access policy assignment. Only "default" policy is supported for now. */
+    accessPolicyName: string;
+    /** The user associated with the access policy. */
+    user: AccessPolicyAssignmentPropertiesUser;
+}
+export declare function accessPolicyAssignmentPropertiesSerializer(item: AccessPolicyAssignmentProperties): any;
+export declare function accessPolicyAssignmentPropertiesDeserializer(item: any): AccessPolicyAssignmentProperties;
+/** The user associated with the access policy. */
+export interface AccessPolicyAssignmentPropertiesUser {
+    /** The object ID of the user. */
+    objectId?: string;
+}
+export declare function accessPolicyAssignmentPropertiesUserSerializer(item: AccessPolicyAssignmentPropertiesUser): any;
+export declare function accessPolicyAssignmentPropertiesUserDeserializer(item: any): AccessPolicyAssignmentPropertiesUser;
+/** The response of a list-all operation. */
+export interface _AccessPolicyAssignmentList {
+    /** The AccessPolicyAssignment items on this page */
+    value: AccessPolicyAssignment[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _accessPolicyAssignmentListDeserializer(item: any): _AccessPolicyAssignmentList;
+export declare function accessPolicyAssignmentArraySerializer(result: Array<AccessPolicyAssignment>): any[];
+export declare function accessPolicyAssignmentArrayDeserializer(result: Array<AccessPolicyAssignment>): any[];
+/** Describes the current migration operation on a Redis Enterprise cluster. */
+export interface Migration extends ProxyResource {
+    /** Properties of the migration operation. */
+    properties?: MigrationPropertiesUnion;
+}
+export declare function migrationSerializer(item: Migration): any;
+export declare function migrationDeserializer(item: any): Migration;
+/** Properties for Redis Enterprise migration operation. */
+export interface MigrationProperties {
+    /** Describes the source of the migration operation. */
+    /** The discriminator possible values: AzureCacheForRedis */
+    sourceType: SourceType;
+    /** The Azure resource ID of the Azure Managed Redis destination cache to migrate. */
+    readonly targetResourceId?: string;
+    /** Current provisioning status of the migration */
+    readonly provisioningState?: MigrationProvisioningState;
+    /** Additional details about the migration operation's status in free text format. */
+    readonly statusDetails?: string;
+    /** The timestamp when the migration operation was created. */
+    readonly creationTime?: Date;
+    /** The timestamp when the migration operation was last updated. */
+    readonly lastModifiedTime?: Date;
+}
+export declare function migrationPropertiesSerializer(item: MigrationProperties): any;
+export declare function migrationPropertiesDeserializer(item: any): MigrationProperties;
+/** Alias for MigrationPropertiesUnion */
+export type MigrationPropertiesUnion = AzureCacheForRedisMigrationProperties | MigrationProperties;
+export declare function migrationPropertiesUnionSerializer(item: MigrationPropertiesUnion): any;
+export declare function migrationPropertiesUnionDeserializer(item: any): MigrationPropertiesUnion;
+/** Describes the source of the migration operation. */
+export declare enum KnownSourceType {
+    /** Migration from Azure Cache for Redis to Redis Enterprise. */
+    AzureCacheForRedis = "AzureCacheForRedis"
+}
+/**
+ * Describes the source of the migration operation. \
+ * {@link KnownSourceType} can be used interchangeably with SourceType,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **AzureCacheForRedis**: Migration from Azure Cache for Redis to Redis Enterprise.
+ */
+export type SourceType = string;
+/** Current provisioning status */
+export declare enum KnownMigrationProvisioningState {
+    /** The request has been accepted and the migration operation is being initialized. */
+    Accepted = "Accepted",
+    /** The migration operation is in progress. */
+    InProgress = "InProgress",
+    /** The migration operation has completed transferring data and is ready for DNS switch. */
+    ReadyForDnsSwitch = "ReadyForDnsSwitch",
+    /** The migration operation has completed successfully. */
+    Succeeded = "Succeeded",
+    /** The migration operation has failed. */
+    Failed = "Failed",
+    /** The migration operation is being cancelled. */
+    Cancelling = "Cancelling",
+    /** The migration operation has been cancelled. */
+    Cancelled = "Cancelled",
+    /** The migration operation cancellation has failed. */
+    CancellationFailed = "CancellationFailed"
+}
+/**
+ * Current provisioning status \
+ * {@link KnownMigrationProvisioningState} can be used interchangeably with MigrationProvisioningState,
+ *  this enum contains the known values that the service supports.
+ * ### Known values supported by the service
+ * **Accepted**: The request has been accepted and the migration operation is being initialized. \
+ * **InProgress**: The migration operation is in progress. \
+ * **ReadyForDnsSwitch**: The migration operation has completed transferring data and is ready for DNS switch. \
+ * **Succeeded**: The migration operation has completed successfully. \
+ * **Failed**: The migration operation has failed. \
+ * **Cancelling**: The migration operation is being cancelled. \
+ * **Cancelled**: The migration operation has been cancelled. \
+ * **CancellationFailed**: The migration operation cancellation has failed.
+ */
+export type MigrationProvisioningState = string;
+/** Properties for Redis Enterprise migration operation for Azure Cache for Redis. */
+export interface AzureCacheForRedisMigrationProperties extends MigrationProperties {
+    /** The source resource ID to migrate from. This is the resource ID of the Azure Cache for Redis. */
+    sourceResourceId: string;
+    /** Sets whether the DNS is switched automatically after the data is transferred from the source cache to the target cache. This property must be true during the preview. */
+    switchDns: boolean;
+    /** Sets whether the data is migrated from source to target or not. This property must be true during the preview. */
+    skipDataMigration: boolean;
+    /** Sets whether to ignore warnings when performing validation of the migration request. If this property is true, warning-level disparities between the source and target resources will be ignored, and the request will only fail validation if there are error-level disparities. The default value is false. */
+    forceMigrate?: boolean;
+    /** Describes the source of the migration operation. */
+    sourceType: "AzureCacheForRedis";
+}
+export declare function azureCacheForRedisMigrationPropertiesSerializer(item: AzureCacheForRedisMigrationProperties): any;
+export declare function azureCacheForRedisMigrationPropertiesDeserializer(item: any): AzureCacheForRedisMigrationProperties;
+/** The response of a list-all migrations. */
+export interface _MigrationList {
+    /** The Migration items on this page */
+    value: Migration[];
+    /** The link to the next page of items */
+    nextLink?: string;
+}
+export declare function _migrationListDeserializer(item: any): _MigrationList;
+export declare function migrationArraySerializer(result: Array<Migration>): any[];
+export declare function migrationArrayDeserializer(result: Array<Migration>): any[];
+/** The status of a long-running operation. */
+export interface OperationStatus {
+    /** The operation's unique id. */
+    id?: string;
+    /** The operation's name. */
+    name?: string;
+    /** The start time of the operation. */
+    startTime?: string;
+    /** The end time of the operation. */
+    endTime?: string;
+    /** The current status of the operation. */
+    status?: string;
+    /** Error response describing why the operation failed. */
+    error?: ErrorResponse;
+}
+export declare function operationStatusDeserializer(item: any): OperationStatus;
+/** The available API versions. */
+export declare enum KnownVersions {
+    /** The 2025-08-01-preview API version. */
+    V20250801Preview = "2025-08-01-preview",
+    /** The 2026-02-01-preview API version. */
+    V20260201Preview = "2026-02-01-preview"
+}
+export declare function _databasePropertiesSerializer(item: Database): any;
+export declare function _databasePropertiesDeserializer(item: any): {
+    clientProtocol: any;
+    port: any;
+    provisioningState: any;
+    resourceState: any;
+    clusteringPolicy: any;
+    evictionPolicy: any;
+    persistence: any;
+    modules: any;
+    geoReplication: any;
+    redisVersion: any;
+    deferUpgrade: any;
+    accessKeysAuthentication: any;
+    notifyKeyspaceEvents: any;
+};
+export declare function _databaseUpdatePropertiesSerializer(item: DatabaseUpdate): any;
+export declare function _privateEndpointConnectionPropertiesSerializer(item: PrivateEndpointConnection): any;
+export declare function _privateEndpointConnectionPropertiesDeserializer(item: any): {
+    groupIds: any;
+    privateEndpoint: any;
+    privateLinkServiceConnectionState: any;
+    provisioningState: any;
+};
+export declare function _clusterPropertiesSerializer(item: Cluster): any;
+export declare function _clusterPropertiesDeserializer(item: any): {
+    highAvailability: any;
+    minimumTlsVersion: any;
+    encryption: any;
+    maintenanceConfiguration: any;
+    hostName: any;
+    provisioningState: any;
+    redundancyMode: any;
+    resourceState: any;
+    redisVersion: any;
+    privateEndpointConnections: any;
+    migratedEndpoint: any;
+    publicNetworkAccess: any;
+};
+export declare function _clusterUpdatePropertiesSerializer(item: ClusterUpdate): any;
+export declare function _privateLinkResourcePropertiesDeserializer(item: any): {
+    groupId: any;
+    requiredMembers: any;
+    requiredZoneNames: any;
+};
+export declare function _accessPolicyAssignmentPropertiesSerializer(item: AccessPolicyAssignment): any;
+export declare function _accessPolicyAssignmentPropertiesDeserializer(item: any): {
+    provisioningState: any;
+    accessPolicyName: any;
+    user: any;
+};
+//# sourceMappingURL=models.d.ts.map