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

package/dist/browser/models/models.js

@@ -0,0 +1,1631 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { areAllPropsUndefined } from "../static-helpers/serialization/check-prop-undefined.js";
+export function _operationListResultDeserializer(item) {
+    return {
+        value: operationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function operationArrayDeserializer(result) {
+    return result.map((item) => {
+        return operationDeserializer(item);
+    });
+}
+export function operationDeserializer(item) {
+    return {
+        name: item["name"],
+        isDataAction: item["isDataAction"],
+        display: !item["display"] ? item["display"] : operationDisplayDeserializer(item["display"]),
+        origin: item["origin"],
+        actionType: item["actionType"],
+    };
+}
+export function operationDisplayDeserializer(item) {
+    return {
+        provider: item["provider"],
+        resource: item["resource"],
+        operation: item["operation"],
+        description: item["description"],
+    };
+}
+/** The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" */
+export var KnownOrigin;
+(function (KnownOrigin) {
+    /** Indicates the operation is initiated by a user. */
+    KnownOrigin["User"] = "user";
+    /** Indicates the operation is initiated by a system. */
+    KnownOrigin["System"] = "system";
+    /** Indicates the operation is initiated by a user or system. */
+    KnownOrigin["UserSystem"] = "user,system";
+})(KnownOrigin || (KnownOrigin = {}));
+/** Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. */
+export var KnownActionType;
+(function (KnownActionType) {
+    /** Actions are for internal-only APIs. */
+    KnownActionType["Internal"] = "Internal";
+})(KnownActionType || (KnownActionType = {}));
+export function errorResponseDeserializer(item) {
+    return {
+        error: !item["error"] ? item["error"] : errorDetailDeserializer(item["error"]),
+    };
+}
+export function errorDetailDeserializer(item) {
+    return {
+        code: item["code"],
+        message: item["message"],
+        target: item["target"],
+        details: !item["details"] ? item["details"] : errorDetailArrayDeserializer(item["details"]),
+        additionalInfo: !item["additionalInfo"]
+            ? item["additionalInfo"]
+            : errorAdditionalInfoArrayDeserializer(item["additionalInfo"]),
+    };
+}
+export function errorDetailArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorDetailDeserializer(item);
+    });
+}
+export function errorAdditionalInfoArrayDeserializer(result) {
+    return result.map((item) => {
+        return errorAdditionalInfoDeserializer(item);
+    });
+}
+export function errorAdditionalInfoDeserializer(item) {
+    return {
+        type: item["type"],
+        info: item["info"],
+    };
+}
+export function databaseSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, [
+            "clientProtocol",
+            "port",
+            "clusteringPolicy",
+            "evictionPolicy",
+            "persistence",
+            "modules",
+            "geoReplication",
+            "deferUpgrade",
+            "accessKeysAuthentication",
+            "notifyKeyspaceEvents",
+        ])
+            ? undefined
+            : _databasePropertiesSerializer(item),
+    };
+}
+export function databaseDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _databasePropertiesDeserializer(item["properties"])),
+    };
+}
+export function databaseCreatePropertiesSerializer(item) {
+    return {
+        clientProtocol: item["clientProtocol"],
+        port: item["port"],
+        clusteringPolicy: item["clusteringPolicy"],
+        evictionPolicy: item["evictionPolicy"],
+        persistence: !item["persistence"]
+            ? item["persistence"]
+            : persistenceSerializer(item["persistence"]),
+        modules: !item["modules"] ? item["modules"] : moduleArraySerializer(item["modules"]),
+        geoReplication: !item["geoReplication"]
+            ? item["geoReplication"]
+            : databaseCommonPropertiesGeoReplicationSerializer(item["geoReplication"]),
+        deferUpgrade: item["deferUpgrade"],
+        accessKeysAuthentication: item["accessKeysAuthentication"],
+        notifyKeyspaceEvents: item["notifyKeyspaceEvents"],
+    };
+}
+export function databaseCreatePropertiesDeserializer(item) {
+    return {
+        clientProtocol: item["clientProtocol"],
+        port: item["port"],
+        provisioningState: item["provisioningState"],
+        resourceState: item["resourceState"],
+        clusteringPolicy: item["clusteringPolicy"],
+        evictionPolicy: item["evictionPolicy"],
+        persistence: !item["persistence"]
+            ? item["persistence"]
+            : persistenceDeserializer(item["persistence"]),
+        modules: !item["modules"] ? item["modules"] : moduleArrayDeserializer(item["modules"]),
+        geoReplication: !item["geoReplication"]
+            ? item["geoReplication"]
+            : databaseCommonPropertiesGeoReplicationDeserializer(item["geoReplication"]),
+        redisVersion: item["redisVersion"],
+        deferUpgrade: item["deferUpgrade"],
+        accessKeysAuthentication: item["accessKeysAuthentication"],
+        notifyKeyspaceEvents: item["notifyKeyspaceEvents"],
+    };
+}
+/** 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 var KnownAccessKeysAuthentication;
+(function (KnownAccessKeysAuthentication) {
+    /** Disabled */
+    KnownAccessKeysAuthentication["Disabled"] = "Disabled";
+    /** Enabled */
+    KnownAccessKeysAuthentication["Enabled"] = "Enabled";
+})(KnownAccessKeysAuthentication || (KnownAccessKeysAuthentication = {}));
+export function databaseCommonPropertiesSerializer(item) {
+    return {
+        clientProtocol: item["clientProtocol"],
+        port: item["port"],
+        clusteringPolicy: item["clusteringPolicy"],
+        evictionPolicy: item["evictionPolicy"],
+        persistence: !item["persistence"]
+            ? item["persistence"]
+            : persistenceSerializer(item["persistence"]),
+        modules: !item["modules"] ? item["modules"] : moduleArraySerializer(item["modules"]),
+        geoReplication: !item["geoReplication"]
+            ? item["geoReplication"]
+            : databaseCommonPropertiesGeoReplicationSerializer(item["geoReplication"]),
+        deferUpgrade: item["deferUpgrade"],
+        accessKeysAuthentication: item["accessKeysAuthentication"],
+        notifyKeyspaceEvents: item["notifyKeyspaceEvents"],
+    };
+}
+export function databaseCommonPropertiesDeserializer(item) {
+    return {
+        clientProtocol: item["clientProtocol"],
+        port: item["port"],
+        provisioningState: item["provisioningState"],
+        resourceState: item["resourceState"],
+        clusteringPolicy: item["clusteringPolicy"],
+        evictionPolicy: item["evictionPolicy"],
+        persistence: !item["persistence"]
+            ? item["persistence"]
+            : persistenceDeserializer(item["persistence"]),
+        modules: !item["modules"] ? item["modules"] : moduleArrayDeserializer(item["modules"]),
+        geoReplication: !item["geoReplication"]
+            ? item["geoReplication"]
+            : databaseCommonPropertiesGeoReplicationDeserializer(item["geoReplication"]),
+        redisVersion: item["redisVersion"],
+        deferUpgrade: item["deferUpgrade"],
+        accessKeysAuthentication: item["accessKeysAuthentication"],
+        notifyKeyspaceEvents: item["notifyKeyspaceEvents"],
+    };
+}
+/** Specifies whether redis clients can connect using TLS-encrypted or plaintext redis protocols. Default is TLS-encrypted. */
+export var KnownProtocol;
+(function (KnownProtocol) {
+    /** Encrypted */
+    KnownProtocol["Encrypted"] = "Encrypted";
+    /** Plaintext */
+    KnownProtocol["Plaintext"] = "Plaintext";
+})(KnownProtocol || (KnownProtocol = {}));
+/** Current provisioning status */
+export var KnownProvisioningState;
+(function (KnownProvisioningState) {
+    /** Succeeded */
+    KnownProvisioningState["Succeeded"] = "Succeeded";
+    /** Failed */
+    KnownProvisioningState["Failed"] = "Failed";
+    /** Canceled */
+    KnownProvisioningState["Canceled"] = "Canceled";
+    /** Creating */
+    KnownProvisioningState["Creating"] = "Creating";
+    /** Updating */
+    KnownProvisioningState["Updating"] = "Updating";
+    /** Deleting */
+    KnownProvisioningState["Deleting"] = "Deleting";
+})(KnownProvisioningState || (KnownProvisioningState = {}));
+/** Current resource status */
+export var KnownResourceState;
+(function (KnownResourceState) {
+    /** Running */
+    KnownResourceState["Running"] = "Running";
+    /** Creating */
+    KnownResourceState["Creating"] = "Creating";
+    /** CreateFailed */
+    KnownResourceState["CreateFailed"] = "CreateFailed";
+    /** Updating */
+    KnownResourceState["Updating"] = "Updating";
+    /** UpdateFailed */
+    KnownResourceState["UpdateFailed"] = "UpdateFailed";
+    /** Deleting */
+    KnownResourceState["Deleting"] = "Deleting";
+    /** DeleteFailed */
+    KnownResourceState["DeleteFailed"] = "DeleteFailed";
+    /** Enabling */
+    KnownResourceState["Enabling"] = "Enabling";
+    /** EnableFailed */
+    KnownResourceState["EnableFailed"] = "EnableFailed";
+    /** Disabling */
+    KnownResourceState["Disabling"] = "Disabling";
+    /** DisableFailed */
+    KnownResourceState["DisableFailed"] = "DisableFailed";
+    /** Disabled */
+    KnownResourceState["Disabled"] = "Disabled";
+    /** Scaling */
+    KnownResourceState["Scaling"] = "Scaling";
+    /** ScalingFailed */
+    KnownResourceState["ScalingFailed"] = "ScalingFailed";
+    /** Moving */
+    KnownResourceState["Moving"] = "Moving";
+})(KnownResourceState || (KnownResourceState = {}));
+/** 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 var KnownClusteringPolicy;
+(function (KnownClusteringPolicy) {
+    /** Enterprise clustering policy uses only the classic redis protocol, which does not support redis cluster commands. */
+    KnownClusteringPolicy["EnterpriseCluster"] = "EnterpriseCluster";
+    /** OSS clustering policy follows the redis cluster specification, and requires all clients to support redis clustering. */
+    KnownClusteringPolicy["OSSCluster"] = "OSSCluster";
+    /** The NoCluster policy is used for non-clustered Redis instances that do not require clustering features. */
+    KnownClusteringPolicy["NoCluster"] = "NoCluster";
+})(KnownClusteringPolicy || (KnownClusteringPolicy = {}));
+/** Redis eviction policy - default is VolatileLRU */
+export var KnownEvictionPolicy;
+(function (KnownEvictionPolicy) {
+    /** AllKeysLFU */
+    KnownEvictionPolicy["AllKeysLFU"] = "AllKeysLFU";
+    /** AllKeysLRU */
+    KnownEvictionPolicy["AllKeysLRU"] = "AllKeysLRU";
+    /** AllKeysRandom */
+    KnownEvictionPolicy["AllKeysRandom"] = "AllKeysRandom";
+    /** VolatileLRU */
+    KnownEvictionPolicy["VolatileLRU"] = "VolatileLRU";
+    /** VolatileLFU */
+    KnownEvictionPolicy["VolatileLFU"] = "VolatileLFU";
+    /** VolatileTTL */
+    KnownEvictionPolicy["VolatileTTL"] = "VolatileTTL";
+    /** VolatileRandom */
+    KnownEvictionPolicy["VolatileRandom"] = "VolatileRandom";
+    /** NoEviction */
+    KnownEvictionPolicy["NoEviction"] = "NoEviction";
+})(KnownEvictionPolicy || (KnownEvictionPolicy = {}));
+export function persistenceSerializer(item) {
+    return {
+        aofEnabled: item["aofEnabled"],
+        rdbEnabled: item["rdbEnabled"],
+        aofFrequency: item["aofFrequency"],
+        rdbFrequency: item["rdbFrequency"],
+    };
+}
+export function persistenceDeserializer(item) {
+    return {
+        aofEnabled: item["aofEnabled"],
+        rdbEnabled: item["rdbEnabled"],
+        aofFrequency: item["aofFrequency"],
+        rdbFrequency: item["rdbFrequency"],
+    };
+}
+/** 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 var KnownAofFrequency;
+(function (KnownAofFrequency) {
+    /** 1s */
+    KnownAofFrequency["OneS"] = "1s";
+    /** always */
+    KnownAofFrequency["Always"] = "always";
+})(KnownAofFrequency || (KnownAofFrequency = {}));
+/** Sets the frequency at which a snapshot of the database is created. */
+export var KnownRdbFrequency;
+(function (KnownRdbFrequency) {
+    /** 1h */
+    KnownRdbFrequency["OneH"] = "1h";
+    /** 6h */
+    KnownRdbFrequency["SixH"] = "6h";
+    /** 12h */
+    KnownRdbFrequency["TwelveH"] = "12h";
+})(KnownRdbFrequency || (KnownRdbFrequency = {}));
+export function moduleArraySerializer(result) {
+    return result.map((item) => {
+        return moduleSerializer(item);
+    });
+}
+export function moduleArrayDeserializer(result) {
+    return result.map((item) => {
+        return moduleDeserializer(item);
+    });
+}
+export function moduleSerializer(item) {
+    return { name: item["name"], args: item["args"] };
+}
+export function moduleDeserializer(item) {
+    return {
+        name: item["name"],
+        args: item["args"],
+        version: item["version"],
+    };
+}
+export function databaseCommonPropertiesGeoReplicationSerializer(item) {
+    return {
+        groupNickname: item["groupNickname"],
+        linkedDatabases: !item["linkedDatabases"]
+            ? item["linkedDatabases"]
+            : linkedDatabaseArraySerializer(item["linkedDatabases"]),
+    };
+}
+export function databaseCommonPropertiesGeoReplicationDeserializer(item) {
+    return {
+        groupNickname: item["groupNickname"],
+        linkedDatabases: !item["linkedDatabases"]
+            ? item["linkedDatabases"]
+            : linkedDatabaseArrayDeserializer(item["linkedDatabases"]),
+    };
+}
+export function linkedDatabaseArraySerializer(result) {
+    return result.map((item) => {
+        return linkedDatabaseSerializer(item);
+    });
+}
+export function linkedDatabaseArrayDeserializer(result) {
+    return result.map((item) => {
+        return linkedDatabaseDeserializer(item);
+    });
+}
+export function linkedDatabaseSerializer(item) {
+    return { id: item["id"] };
+}
+export function linkedDatabaseDeserializer(item) {
+    return {
+        id: item["id"],
+        state: item["state"],
+    };
+}
+/** State of the link between the database resources. */
+export var KnownLinkState;
+(function (KnownLinkState) {
+    /** Linked */
+    KnownLinkState["Linked"] = "Linked";
+    /** Linking */
+    KnownLinkState["Linking"] = "Linking";
+    /** Unlinking */
+    KnownLinkState["Unlinking"] = "Unlinking";
+    /** LinkFailed */
+    KnownLinkState["LinkFailed"] = "LinkFailed";
+    /** UnlinkFailed */
+    KnownLinkState["UnlinkFailed"] = "UnlinkFailed";
+})(KnownLinkState || (KnownLinkState = {}));
+/** Option to defer upgrade when newest version is released - default is NotDeferred. Learn more: https://aka.ms/redisversionupgrade */
+export var KnownDeferUpgradeSetting;
+(function (KnownDeferUpgradeSetting) {
+    /** Deferred */
+    KnownDeferUpgradeSetting["Deferred"] = "Deferred";
+    /** NotDeferred */
+    KnownDeferUpgradeSetting["NotDeferred"] = "NotDeferred";
+})(KnownDeferUpgradeSetting || (KnownDeferUpgradeSetting = {}));
+export function proxyResourceSerializer(_item) {
+    return {};
+}
+export function proxyResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function resourceSerializer(_item) {
+    return {};
+}
+export function resourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+    };
+}
+export function systemDataDeserializer(item) {
+    return {
+        createdBy: item["createdBy"],
+        createdByType: item["createdByType"],
+        createdAt: !item["createdAt"] ? item["createdAt"] : new Date(item["createdAt"]),
+        lastModifiedBy: item["lastModifiedBy"],
+        lastModifiedByType: item["lastModifiedByType"],
+        lastModifiedAt: !item["lastModifiedAt"]
+            ? item["lastModifiedAt"]
+            : new Date(item["lastModifiedAt"]),
+    };
+}
+/** The kind of entity that created the resource. */
+export var KnownCreatedByType;
+(function (KnownCreatedByType) {
+    /** The entity was created by a user. */
+    KnownCreatedByType["User"] = "User";
+    /** The entity was created by an application. */
+    KnownCreatedByType["Application"] = "Application";
+    /** The entity was created by a managed identity. */
+    KnownCreatedByType["ManagedIdentity"] = "ManagedIdentity";
+    /** The entity was created by a key. */
+    KnownCreatedByType["Key"] = "Key";
+})(KnownCreatedByType || (KnownCreatedByType = {}));
+export function databaseUpdateSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, [
+            "clientProtocol",
+            "port",
+            "clusteringPolicy",
+            "evictionPolicy",
+            "persistence",
+            "modules",
+            "geoReplication",
+            "deferUpgrade",
+            "accessKeysAuthentication",
+            "notifyKeyspaceEvents",
+        ])
+            ? undefined
+            : _databaseUpdatePropertiesSerializer(item),
+    };
+}
+export function databaseUpdatePropertiesSerializer(item) {
+    return {
+        clientProtocol: item["clientProtocol"],
+        port: item["port"],
+        clusteringPolicy: item["clusteringPolicy"],
+        evictionPolicy: item["evictionPolicy"],
+        persistence: !item["persistence"]
+            ? item["persistence"]
+            : persistenceSerializer(item["persistence"]),
+        modules: !item["modules"] ? item["modules"] : moduleArraySerializer(item["modules"]),
+        geoReplication: !item["geoReplication"]
+            ? item["geoReplication"]
+            : databaseCommonPropertiesGeoReplicationSerializer(item["geoReplication"]),
+        deferUpgrade: item["deferUpgrade"],
+        accessKeysAuthentication: item["accessKeysAuthentication"],
+        notifyKeyspaceEvents: item["notifyKeyspaceEvents"],
+    };
+}
+export function _databaseListDeserializer(item) {
+    return {
+        value: databaseArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function databaseArraySerializer(result) {
+    return result.map((item) => {
+        return databaseSerializer(item);
+    });
+}
+export function databaseArrayDeserializer(result) {
+    return result.map((item) => {
+        return databaseDeserializer(item);
+    });
+}
+export function accessKeysDeserializer(item) {
+    return {
+        primaryKey: item["primaryKey"],
+        secondaryKey: item["secondaryKey"],
+    };
+}
+export function regenerateKeyParametersSerializer(item) {
+    return { keyType: item["keyType"] };
+}
+export function importClusterParametersSerializer(item) {
+    return {
+        sasUris: item["sasUris"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function exportClusterParametersSerializer(item) {
+    return { sasUri: item["sasUri"] };
+}
+export function forceUnlinkParametersSerializer(item) {
+    return {
+        ids: item["ids"].map((p) => {
+            return p;
+        }),
+    };
+}
+export function forceLinkParametersSerializer(item) {
+    return { geoReplication: forceLinkParametersGeoReplicationSerializer(item["geoReplication"]) };
+}
+export function forceLinkParametersGeoReplicationSerializer(item) {
+    return {
+        groupNickname: item["groupNickname"],
+        linkedDatabases: !item["linkedDatabases"]
+            ? item["linkedDatabases"]
+            : linkedDatabaseArraySerializer(item["linkedDatabases"]),
+    };
+}
+export function flushParametersSerializer(item) {
+    return {
+        ids: !item["ids"]
+            ? item["ids"]
+            : item["ids"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function privateEndpointConnectionSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["privateEndpoint", "privateLinkServiceConnectionState"])
+            ? undefined
+            : _privateEndpointConnectionPropertiesSerializer(item),
+    };
+}
+export function privateEndpointConnectionDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _privateEndpointConnectionPropertiesDeserializer(item["properties"])),
+    };
+}
+export function privateEndpointConnectionPropertiesSerializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointSerializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: privateLinkServiceConnectionStateSerializer(item["privateLinkServiceConnectionState"]),
+    };
+}
+export function privateEndpointConnectionPropertiesDeserializer(item) {
+    return {
+        groupIds: !item["groupIds"]
+            ? item["groupIds"]
+            : item["groupIds"].map((p) => {
+                return p;
+            }),
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: privateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+        provisioningState: item["provisioningState"],
+    };
+}
+export function privateEndpointSerializer(_item) {
+    return {};
+}
+export function privateEndpointDeserializer(item) {
+    return {
+        id: item["id"],
+    };
+}
+export function privateLinkServiceConnectionStateSerializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+export function privateLinkServiceConnectionStateDeserializer(item) {
+    return {
+        status: item["status"],
+        description: item["description"],
+        actionsRequired: item["actionsRequired"],
+    };
+}
+/** The private endpoint connection status. */
+export var KnownPrivateEndpointServiceConnectionStatus;
+(function (KnownPrivateEndpointServiceConnectionStatus) {
+    /** Connection waiting for approval or rejection */
+    KnownPrivateEndpointServiceConnectionStatus["Pending"] = "Pending";
+    /** Connection approved */
+    KnownPrivateEndpointServiceConnectionStatus["Approved"] = "Approved";
+    /** Connection Rejected */
+    KnownPrivateEndpointServiceConnectionStatus["Rejected"] = "Rejected";
+})(KnownPrivateEndpointServiceConnectionStatus || (KnownPrivateEndpointServiceConnectionStatus = {}));
+/** The current provisioning state. */
+export var KnownPrivateEndpointConnectionProvisioningState;
+(function (KnownPrivateEndpointConnectionProvisioningState) {
+    /** Connection has been provisioned */
+    KnownPrivateEndpointConnectionProvisioningState["Succeeded"] = "Succeeded";
+    /** Connection is being created */
+    KnownPrivateEndpointConnectionProvisioningState["Creating"] = "Creating";
+    /** Connection is being deleted */
+    KnownPrivateEndpointConnectionProvisioningState["Deleting"] = "Deleting";
+    /** Connection provisioning has failed */
+    KnownPrivateEndpointConnectionProvisioningState["Failed"] = "Failed";
+})(KnownPrivateEndpointConnectionProvisioningState || (KnownPrivateEndpointConnectionProvisioningState = {}));
+export function _privateEndpointConnectionListResultDeserializer(item) {
+    return {
+        value: privateEndpointConnectionArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function privateEndpointConnectionArraySerializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionSerializer(item);
+    });
+}
+export function privateEndpointConnectionArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateEndpointConnectionDeserializer(item);
+    });
+}
+export function migrationValidationRequestSerializer(item) {
+    return {
+        sourceResourceId: item["sourceResourceId"],
+        skipDataMigration: item["skipDataMigration"],
+        forceMigrate: item["forceMigrate"],
+    };
+}
+export function migrationValidationResponseDeserializer(item) {
+    return {
+        isValid: item["isValid"],
+        errors: !item["errors"]
+            ? item["errors"]
+            : migrationValidationErrorArrayDeserializer(item["errors"]),
+        warnings: !item["warnings"]
+            ? item["warnings"]
+            : migrationValidationWarningArrayDeserializer(item["warnings"]),
+    };
+}
+export function migrationValidationErrorArrayDeserializer(result) {
+    return result.map((item) => {
+        return migrationValidationErrorDeserializer(item);
+    });
+}
+export function migrationValidationErrorDeserializer(item) {
+    return {
+        disparities: migrationValidationDisparityArrayDeserializer(item["disparities"]),
+    };
+}
+export function migrationValidationDisparityArrayDeserializer(result) {
+    return result.map((item) => {
+        return migrationValidationDisparityDeserializer(item);
+    });
+}
+export function migrationValidationDisparityDeserializer(item) {
+    return {
+        category: item["category"],
+        message: item["message"],
+    };
+}
+export function migrationValidationWarningArrayDeserializer(result) {
+    return result.map((item) => {
+        return migrationValidationWarningDeserializer(item);
+    });
+}
+export function migrationValidationWarningDeserializer(item) {
+    return {
+        disparities: migrationValidationDisparityArrayDeserializer(item["disparities"]),
+    };
+}
+export function clusterSerializer(item) {
+    return {
+        tags: item["tags"],
+        location: item["location"],
+        properties: areAllPropsUndefined(item, [
+            "highAvailability",
+            "minimumTlsVersion",
+            "encryption",
+            "maintenanceConfiguration",
+            "publicNetworkAccess",
+        ])
+            ? undefined
+            : _clusterPropertiesSerializer(item),
+        sku: skuSerializer(item["sku"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentitySerializer(item["identity"]),
+    };
+}
+export function clusterDeserializer(item) {
+    return {
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _clusterPropertiesDeserializer(item["properties"])),
+        kind: item["kind"],
+        sku: skuDeserializer(item["sku"]),
+        zones: !item["zones"]
+            ? item["zones"]
+            : item["zones"].map((p) => {
+                return p;
+            }),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentityDeserializer(item["identity"]),
+    };
+}
+export function clusterCreatePropertiesSerializer(item) {
+    return {
+        highAvailability: item["highAvailability"],
+        minimumTlsVersion: item["minimumTlsVersion"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : clusterCommonPropertiesEncryptionSerializer(item["encryption"]),
+        maintenanceConfiguration: !item["maintenanceConfiguration"]
+            ? item["maintenanceConfiguration"]
+            : maintenanceConfigurationSerializer(item["maintenanceConfiguration"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+    };
+}
+export function clusterCreatePropertiesDeserializer(item) {
+    return {
+        highAvailability: item["highAvailability"],
+        minimumTlsVersion: item["minimumTlsVersion"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : clusterCommonPropertiesEncryptionDeserializer(item["encryption"]),
+        maintenanceConfiguration: !item["maintenanceConfiguration"]
+            ? item["maintenanceConfiguration"]
+            : maintenanceConfigurationDeserializer(item["maintenanceConfiguration"]),
+        hostName: item["hostName"],
+        provisioningState: item["provisioningState"],
+        redundancyMode: item["redundancyMode"],
+        resourceState: item["resourceState"],
+        redisVersion: item["redisVersion"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        migratedEndpoint: item["migratedEndpoint"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+    };
+}
+/** 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 var KnownPublicNetworkAccess;
+(function (KnownPublicNetworkAccess) {
+    /** Enabled */
+    KnownPublicNetworkAccess["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownPublicNetworkAccess["Disabled"] = "Disabled";
+})(KnownPublicNetworkAccess || (KnownPublicNetworkAccess = {}));
+/** Distinguishes the kind of cluster. Read-only. */
+export var KnownKind;
+(function (KnownKind) {
+    /** v1 */
+    KnownKind["V1"] = "v1";
+    /** v2 */
+    KnownKind["V2"] = "v2";
+})(KnownKind || (KnownKind = {}));
+export function skuSerializer(item) {
+    return { name: item["name"], capacity: item["capacity"] };
+}
+export function skuDeserializer(item) {
+    return {
+        name: item["name"],
+        capacity: item["capacity"],
+    };
+}
+/** 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 var KnownSkuName;
+(function (KnownSkuName) {
+    /** Enterprise_E1 */
+    KnownSkuName["EnterpriseE1"] = "Enterprise_E1";
+    /** Enterprise_E5 */
+    KnownSkuName["EnterpriseE5"] = "Enterprise_E5";
+    /** Enterprise_E10 */
+    KnownSkuName["EnterpriseE10"] = "Enterprise_E10";
+    /** Enterprise_E20 */
+    KnownSkuName["EnterpriseE20"] = "Enterprise_E20";
+    /** Enterprise_E50 */
+    KnownSkuName["EnterpriseE50"] = "Enterprise_E50";
+    /** Enterprise_E100 */
+    KnownSkuName["EnterpriseE100"] = "Enterprise_E100";
+    /** Enterprise_E200 */
+    KnownSkuName["EnterpriseE200"] = "Enterprise_E200";
+    /** Enterprise_E400 */
+    KnownSkuName["EnterpriseE400"] = "Enterprise_E400";
+    /** EnterpriseFlash_F300 */
+    KnownSkuName["EnterpriseFlashF300"] = "EnterpriseFlash_F300";
+    /** EnterpriseFlash_F700 */
+    KnownSkuName["EnterpriseFlashF700"] = "EnterpriseFlash_F700";
+    /** EnterpriseFlash_F1500 */
+    KnownSkuName["EnterpriseFlashF1500"] = "EnterpriseFlash_F1500";
+    /** Balanced_B0 */
+    KnownSkuName["BalancedB0"] = "Balanced_B0";
+    /** Balanced_B1 */
+    KnownSkuName["BalancedB1"] = "Balanced_B1";
+    /** Balanced_B3 */
+    KnownSkuName["BalancedB3"] = "Balanced_B3";
+    /** Balanced_B5 */
+    KnownSkuName["BalancedB5"] = "Balanced_B5";
+    /** Balanced_B10 */
+    KnownSkuName["BalancedB10"] = "Balanced_B10";
+    /** Balanced_B20 */
+    KnownSkuName["BalancedB20"] = "Balanced_B20";
+    /** Balanced_B50 */
+    KnownSkuName["BalancedB50"] = "Balanced_B50";
+    /** Balanced_B100 */
+    KnownSkuName["BalancedB100"] = "Balanced_B100";
+    /** Balanced_B150 */
+    KnownSkuName["BalancedB150"] = "Balanced_B150";
+    /** Balanced_B250 */
+    KnownSkuName["BalancedB250"] = "Balanced_B250";
+    /** Balanced_B350 */
+    KnownSkuName["BalancedB350"] = "Balanced_B350";
+    /** Balanced_B500 */
+    KnownSkuName["BalancedB500"] = "Balanced_B500";
+    /** Balanced_B700 */
+    KnownSkuName["BalancedB700"] = "Balanced_B700";
+    /** Balanced_B1000 */
+    KnownSkuName["BalancedB1000"] = "Balanced_B1000";
+    /** MemoryOptimized_M10 */
+    KnownSkuName["MemoryOptimizedM10"] = "MemoryOptimized_M10";
+    /** MemoryOptimized_M20 */
+    KnownSkuName["MemoryOptimizedM20"] = "MemoryOptimized_M20";
+    /** MemoryOptimized_M50 */
+    KnownSkuName["MemoryOptimizedM50"] = "MemoryOptimized_M50";
+    /** MemoryOptimized_M100 */
+    KnownSkuName["MemoryOptimizedM100"] = "MemoryOptimized_M100";
+    /** MemoryOptimized_M150 */
+    KnownSkuName["MemoryOptimizedM150"] = "MemoryOptimized_M150";
+    /** MemoryOptimized_M250 */
+    KnownSkuName["MemoryOptimizedM250"] = "MemoryOptimized_M250";
+    /** MemoryOptimized_M350 */
+    KnownSkuName["MemoryOptimizedM350"] = "MemoryOptimized_M350";
+    /** MemoryOptimized_M500 */
+    KnownSkuName["MemoryOptimizedM500"] = "MemoryOptimized_M500";
+    /** MemoryOptimized_M700 */
+    KnownSkuName["MemoryOptimizedM700"] = "MemoryOptimized_M700";
+    /** MemoryOptimized_M1000 */
+    KnownSkuName["MemoryOptimizedM1000"] = "MemoryOptimized_M1000";
+    /** MemoryOptimized_M1500 */
+    KnownSkuName["MemoryOptimizedM1500"] = "MemoryOptimized_M1500";
+    /** MemoryOptimized_M2000 */
+    KnownSkuName["MemoryOptimizedM2000"] = "MemoryOptimized_M2000";
+    /** ComputeOptimized_X3 */
+    KnownSkuName["ComputeOptimizedX3"] = "ComputeOptimized_X3";
+    /** ComputeOptimized_X5 */
+    KnownSkuName["ComputeOptimizedX5"] = "ComputeOptimized_X5";
+    /** ComputeOptimized_X10 */
+    KnownSkuName["ComputeOptimizedX10"] = "ComputeOptimized_X10";
+    /** ComputeOptimized_X20 */
+    KnownSkuName["ComputeOptimizedX20"] = "ComputeOptimized_X20";
+    /** ComputeOptimized_X50 */
+    KnownSkuName["ComputeOptimizedX50"] = "ComputeOptimized_X50";
+    /** ComputeOptimized_X100 */
+    KnownSkuName["ComputeOptimizedX100"] = "ComputeOptimized_X100";
+    /** ComputeOptimized_X150 */
+    KnownSkuName["ComputeOptimizedX150"] = "ComputeOptimized_X150";
+    /** ComputeOptimized_X250 */
+    KnownSkuName["ComputeOptimizedX250"] = "ComputeOptimized_X250";
+    /** ComputeOptimized_X350 */
+    KnownSkuName["ComputeOptimizedX350"] = "ComputeOptimized_X350";
+    /** ComputeOptimized_X500 */
+    KnownSkuName["ComputeOptimizedX500"] = "ComputeOptimized_X500";
+    /** ComputeOptimized_X700 */
+    KnownSkuName["ComputeOptimizedX700"] = "ComputeOptimized_X700";
+    /** FlashOptimized_A250 */
+    KnownSkuName["FlashOptimizedA250"] = "FlashOptimized_A250";
+    /** FlashOptimized_A500 */
+    KnownSkuName["FlashOptimizedA500"] = "FlashOptimized_A500";
+    /** FlashOptimized_A700 */
+    KnownSkuName["FlashOptimizedA700"] = "FlashOptimized_A700";
+    /** FlashOptimized_A1000 */
+    KnownSkuName["FlashOptimizedA1000"] = "FlashOptimized_A1000";
+    /** FlashOptimized_A1500 */
+    KnownSkuName["FlashOptimizedA1500"] = "FlashOptimized_A1500";
+    /** FlashOptimized_A2000 */
+    KnownSkuName["FlashOptimizedA2000"] = "FlashOptimized_A2000";
+    /** FlashOptimized_A4500 */
+    KnownSkuName["FlashOptimizedA4500"] = "FlashOptimized_A4500";
+})(KnownSkuName || (KnownSkuName = {}));
+export function managedServiceIdentitySerializer(item) {
+    return {
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentityRecordSerializer(item["userAssignedIdentities"]),
+    };
+}
+export function managedServiceIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        tenantId: item["tenantId"],
+        type: item["type"],
+        userAssignedIdentities: !item["userAssignedIdentities"]
+            ? item["userAssignedIdentities"]
+            : userAssignedIdentityRecordDeserializer(item["userAssignedIdentities"]),
+    };
+}
+/** Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). */
+export var KnownManagedServiceIdentityType;
+(function (KnownManagedServiceIdentityType) {
+    /** No managed identity. */
+    KnownManagedServiceIdentityType["None"] = "None";
+    /** System assigned managed identity. */
+    KnownManagedServiceIdentityType["SystemAssigned"] = "SystemAssigned";
+    /** User assigned managed identity. */
+    KnownManagedServiceIdentityType["UserAssigned"] = "UserAssigned";
+    /** System and user assigned managed identity. */
+    KnownManagedServiceIdentityType["SystemAssignedUserAssigned"] = "SystemAssigned, UserAssigned";
+})(KnownManagedServiceIdentityType || (KnownManagedServiceIdentityType = {}));
+export function userAssignedIdentityRecordSerializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentitySerializer(item[key]);
+    });
+    return result;
+}
+export function userAssignedIdentityRecordDeserializer(item) {
+    const result = {};
+    Object.keys(item).map((key) => {
+        result[key] = !item[key] ? item[key] : userAssignedIdentityDeserializer(item[key]);
+    });
+    return result;
+}
+export function userAssignedIdentitySerializer(_item) {
+    return {};
+}
+export function userAssignedIdentityDeserializer(item) {
+    return {
+        principalId: item["principalId"],
+        clientId: item["clientId"],
+    };
+}
+export function clusterCommonPropertiesSerializer(item) {
+    return {
+        highAvailability: item["highAvailability"],
+        minimumTlsVersion: item["minimumTlsVersion"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : clusterCommonPropertiesEncryptionSerializer(item["encryption"]),
+        maintenanceConfiguration: !item["maintenanceConfiguration"]
+            ? item["maintenanceConfiguration"]
+            : maintenanceConfigurationSerializer(item["maintenanceConfiguration"]),
+    };
+}
+export function clusterCommonPropertiesDeserializer(item) {
+    return {
+        highAvailability: item["highAvailability"],
+        minimumTlsVersion: item["minimumTlsVersion"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : clusterCommonPropertiesEncryptionDeserializer(item["encryption"]),
+        maintenanceConfiguration: !item["maintenanceConfiguration"]
+            ? item["maintenanceConfiguration"]
+            : maintenanceConfigurationDeserializer(item["maintenanceConfiguration"]),
+        hostName: item["hostName"],
+        provisioningState: item["provisioningState"],
+        redundancyMode: item["redundancyMode"],
+        resourceState: item["resourceState"],
+        redisVersion: item["redisVersion"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        migratedEndpoint: item["migratedEndpoint"],
+    };
+}
+/** 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 var KnownHighAvailability;
+(function (KnownHighAvailability) {
+    /** Enabled */
+    KnownHighAvailability["Enabled"] = "Enabled";
+    /** Disabled */
+    KnownHighAvailability["Disabled"] = "Disabled";
+})(KnownHighAvailability || (KnownHighAvailability = {}));
+/** 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 var KnownTlsVersion;
+(function (KnownTlsVersion) {
+    /** 1.0 */
+    KnownTlsVersion["One0"] = "1.0";
+    /** 1.1 */
+    KnownTlsVersion["One1"] = "1.1";
+    /** 1.2 */
+    KnownTlsVersion["One2"] = "1.2";
+})(KnownTlsVersion || (KnownTlsVersion = {}));
+export function clusterCommonPropertiesEncryptionSerializer(item) {
+    return {
+        customerManagedKeyEncryption: !item["customerManagedKeyEncryption"]
+            ? item["customerManagedKeyEncryption"]
+            : clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionSerializer(item["customerManagedKeyEncryption"]),
+    };
+}
+export function clusterCommonPropertiesEncryptionDeserializer(item) {
+    return {
+        customerManagedKeyEncryption: !item["customerManagedKeyEncryption"]
+            ? item["customerManagedKeyEncryption"]
+            : clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionDeserializer(item["customerManagedKeyEncryption"]),
+    };
+}
+export function clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionSerializer(item) {
+    return {
+        keyEncryptionKeyIdentity: !item["keyEncryptionKeyIdentity"]
+            ? item["keyEncryptionKeyIdentity"]
+            : clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentitySerializer(item["keyEncryptionKeyIdentity"]),
+        keyEncryptionKeyUrl: item["keyEncryptionKeyUrl"],
+    };
+}
+export function clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionDeserializer(item) {
+    return {
+        keyEncryptionKeyIdentity: !item["keyEncryptionKeyIdentity"]
+            ? item["keyEncryptionKeyIdentity"]
+            : clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentityDeserializer(item["keyEncryptionKeyIdentity"]),
+        keyEncryptionKeyUrl: item["keyEncryptionKeyUrl"],
+    };
+}
+export function clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentitySerializer(item) {
+    return {
+        userAssignedIdentityResourceId: item["userAssignedIdentityResourceId"],
+        identityType: item["identityType"],
+    };
+}
+export function clusterCommonPropertiesEncryptionCustomerManagedKeyEncryptionKeyIdentityDeserializer(item) {
+    return {
+        userAssignedIdentityResourceId: item["userAssignedIdentityResourceId"],
+        identityType: item["identityType"],
+    };
+}
+/** Only userAssignedIdentity is supported in this API version; other types may be supported in the future */
+export var KnownCmkIdentityType;
+(function (KnownCmkIdentityType) {
+    /** systemAssignedIdentity */
+    KnownCmkIdentityType["SystemAssignedIdentity"] = "systemAssignedIdentity";
+    /** userAssignedIdentity */
+    KnownCmkIdentityType["UserAssignedIdentity"] = "userAssignedIdentity";
+})(KnownCmkIdentityType || (KnownCmkIdentityType = {}));
+export function maintenanceConfigurationSerializer(item) {
+    return {
+        maintenanceWindows: !item["maintenanceWindows"]
+            ? item["maintenanceWindows"]
+            : maintenanceWindowArraySerializer(item["maintenanceWindows"]),
+    };
+}
+export function maintenanceConfigurationDeserializer(item) {
+    return {
+        maintenanceWindows: !item["maintenanceWindows"]
+            ? item["maintenanceWindows"]
+            : maintenanceWindowArrayDeserializer(item["maintenanceWindows"]),
+    };
+}
+export function maintenanceWindowArraySerializer(result) {
+    return result.map((item) => {
+        return maintenanceWindowSerializer(item);
+    });
+}
+export function maintenanceWindowArrayDeserializer(result) {
+    return result.map((item) => {
+        return maintenanceWindowDeserializer(item);
+    });
+}
+export function maintenanceWindowSerializer(item) {
+    return {
+        type: item["type"],
+        duration: item["duration"],
+        startHourUtc: item["startHourUtc"],
+        schedule: maintenanceWindowScheduleSerializer(item["schedule"]),
+    };
+}
+export function maintenanceWindowDeserializer(item) {
+    return {
+        type: item["type"],
+        duration: item["duration"],
+        startHourUtc: item["startHourUtc"],
+        schedule: maintenanceWindowScheduleDeserializer(item["schedule"]),
+    };
+}
+/** Maintenance window type. */
+export var KnownMaintenanceWindowType;
+(function (KnownMaintenanceWindowType) {
+    /** Weekly maintenance window. */
+    KnownMaintenanceWindowType["Weekly"] = "Weekly";
+})(KnownMaintenanceWindowType || (KnownMaintenanceWindowType = {}));
+export function maintenanceWindowScheduleSerializer(item) {
+    return { dayOfWeek: item["dayOfWeek"] };
+}
+export function maintenanceWindowScheduleDeserializer(item) {
+    return {
+        dayOfWeek: item["dayOfWeek"],
+    };
+}
+/** Day of week. Required when the maintenance window type is 'Weekly'. */
+export var KnownMaintenanceDayOfWeek;
+(function (KnownMaintenanceDayOfWeek) {
+    /** Sunday */
+    KnownMaintenanceDayOfWeek["Sunday"] = "Sunday";
+    /** Monday */
+    KnownMaintenanceDayOfWeek["Monday"] = "Monday";
+    /** Tuesday */
+    KnownMaintenanceDayOfWeek["Tuesday"] = "Tuesday";
+    /** Wednesday */
+    KnownMaintenanceDayOfWeek["Wednesday"] = "Wednesday";
+    /** Thursday */
+    KnownMaintenanceDayOfWeek["Thursday"] = "Thursday";
+    /** Friday */
+    KnownMaintenanceDayOfWeek["Friday"] = "Friday";
+    /** Saturday */
+    KnownMaintenanceDayOfWeek["Saturday"] = "Saturday";
+})(KnownMaintenanceDayOfWeek || (KnownMaintenanceDayOfWeek = {}));
+/** Explains the current redundancy strategy of the cluster, which affects the expected SLA. */
+export var KnownRedundancyMode;
+(function (KnownRedundancyMode) {
+    /** No redundancy. Availability loss will occur. */
+    KnownRedundancyMode["None"] = "None";
+    /** Local redundancy with high availability. */
+    KnownRedundancyMode["LR"] = "LR";
+    /** Zone redundant. Higher availability. */
+    KnownRedundancyMode["ZR"] = "ZR";
+})(KnownRedundancyMode || (KnownRedundancyMode = {}));
+export function trackedResourceSerializer(item) {
+    return { tags: item["tags"], location: item["location"] };
+}
+export function trackedResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        tags: !item["tags"]
+            ? item["tags"]
+            : Object.fromEntries(Object.entries(item["tags"]).map(([k, p]) => [k, p])),
+        location: item["location"],
+    };
+}
+export function clusterUpdateSerializer(item) {
+    return {
+        sku: !item["sku"] ? item["sku"] : skuSerializer(item["sku"]),
+        properties: areAllPropsUndefined(item, [
+            "highAvailability",
+            "minimumTlsVersion",
+            "encryption",
+            "maintenanceConfiguration",
+            "publicNetworkAccess",
+        ])
+            ? undefined
+            : _clusterUpdatePropertiesSerializer(item),
+        identity: !item["identity"]
+            ? item["identity"]
+            : managedServiceIdentitySerializer(item["identity"]),
+        tags: item["tags"],
+    };
+}
+export function clusterUpdatePropertiesSerializer(item) {
+    return {
+        highAvailability: item["highAvailability"],
+        minimumTlsVersion: item["minimumTlsVersion"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : clusterCommonPropertiesEncryptionSerializer(item["encryption"]),
+        maintenanceConfiguration: !item["maintenanceConfiguration"]
+            ? item["maintenanceConfiguration"]
+            : maintenanceConfigurationSerializer(item["maintenanceConfiguration"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+    };
+}
+export function _clusterListDeserializer(item) {
+    return {
+        value: clusterArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function clusterArraySerializer(result) {
+    return result.map((item) => {
+        return clusterSerializer(item);
+    });
+}
+export function clusterArrayDeserializer(result) {
+    return result.map((item) => {
+        return clusterDeserializer(item);
+    });
+}
+export function skuDetailsListDeserializer(item) {
+    return {
+        skus: !item["skus"] ? item["skus"] : skuDetailsArrayDeserializer(item["skus"]),
+    };
+}
+export function skuDetailsArrayDeserializer(result) {
+    return result.map((item) => {
+        return skuDetailsDeserializer(item);
+    });
+}
+export function skuDetailsDeserializer(item) {
+    return {
+        name: item["name"],
+        sizeInGB: item["sizeInGB"],
+    };
+}
+export function _privateLinkResourceListResultDeserializer(item) {
+    return {
+        value: !item["value"] ? item["value"] : privateLinkResourceArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function privateLinkResourceArrayDeserializer(result) {
+    return result.map((item) => {
+        return privateLinkResourceDeserializer(item);
+    });
+}
+export function privateLinkResourceDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _privateLinkResourcePropertiesDeserializer(item["properties"])),
+    };
+}
+export function privateLinkResourcePropertiesDeserializer(item) {
+    return {
+        groupId: item["groupId"],
+        requiredMembers: !item["requiredMembers"]
+            ? item["requiredMembers"]
+            : item["requiredMembers"].map((p) => {
+                return p;
+            }),
+        requiredZoneNames: !item["requiredZoneNames"]
+            ? item["requiredZoneNames"]
+            : item["requiredZoneNames"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function accessPolicyAssignmentSerializer(item) {
+    return {
+        properties: areAllPropsUndefined(item, ["accessPolicyName", "user"])
+            ? undefined
+            : _accessPolicyAssignmentPropertiesSerializer(item),
+    };
+}
+export function accessPolicyAssignmentDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        ...(!item["properties"]
+            ? item["properties"]
+            : _accessPolicyAssignmentPropertiesDeserializer(item["properties"])),
+    };
+}
+export function accessPolicyAssignmentPropertiesSerializer(item) {
+    return {
+        accessPolicyName: item["accessPolicyName"],
+        user: accessPolicyAssignmentPropertiesUserSerializer(item["user"]),
+    };
+}
+export function accessPolicyAssignmentPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        accessPolicyName: item["accessPolicyName"],
+        user: accessPolicyAssignmentPropertiesUserDeserializer(item["user"]),
+    };
+}
+export function accessPolicyAssignmentPropertiesUserSerializer(item) {
+    return { objectId: item["objectId"] };
+}
+export function accessPolicyAssignmentPropertiesUserDeserializer(item) {
+    return {
+        objectId: item["objectId"],
+    };
+}
+export function _accessPolicyAssignmentListDeserializer(item) {
+    return {
+        value: accessPolicyAssignmentArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function accessPolicyAssignmentArraySerializer(result) {
+    return result.map((item) => {
+        return accessPolicyAssignmentSerializer(item);
+    });
+}
+export function accessPolicyAssignmentArrayDeserializer(result) {
+    return result.map((item) => {
+        return accessPolicyAssignmentDeserializer(item);
+    });
+}
+export function migrationSerializer(item) {
+    return {
+        properties: !item["properties"]
+            ? item["properties"]
+            : migrationPropertiesUnionSerializer(item["properties"]),
+    };
+}
+export function migrationDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        type: item["type"],
+        systemData: !item["systemData"]
+            ? item["systemData"]
+            : systemDataDeserializer(item["systemData"]),
+        properties: !item["properties"]
+            ? item["properties"]
+            : migrationPropertiesUnionDeserializer(item["properties"]),
+    };
+}
+export function migrationPropertiesSerializer(item) {
+    return { sourceType: item["sourceType"] };
+}
+export function migrationPropertiesDeserializer(item) {
+    return {
+        sourceType: item["sourceType"],
+        targetResourceId: item["targetResourceId"],
+        provisioningState: item["provisioningState"],
+        statusDetails: item["statusDetails"],
+        creationTime: !item["creationTime"] ? item["creationTime"] : new Date(item["creationTime"]),
+        lastModifiedTime: !item["lastModifiedTime"]
+            ? item["lastModifiedTime"]
+            : new Date(item["lastModifiedTime"]),
+    };
+}
+export function migrationPropertiesUnionSerializer(item) {
+    switch (item.sourceType) {
+        case "AzureCacheForRedis":
+            return azureCacheForRedisMigrationPropertiesSerializer(item);
+        default:
+            return migrationPropertiesSerializer(item);
+    }
+}
+export function migrationPropertiesUnionDeserializer(item) {
+    switch (item["sourceType"]) {
+        case "AzureCacheForRedis":
+            return azureCacheForRedisMigrationPropertiesDeserializer(item);
+        default:
+            return migrationPropertiesDeserializer(item);
+    }
+}
+/** Describes the source of the migration operation. */
+export var KnownSourceType;
+(function (KnownSourceType) {
+    /** Migration from Azure Cache for Redis to Redis Enterprise. */
+    KnownSourceType["AzureCacheForRedis"] = "AzureCacheForRedis";
+})(KnownSourceType || (KnownSourceType = {}));
+/** Current provisioning status */
+export var KnownMigrationProvisioningState;
+(function (KnownMigrationProvisioningState) {
+    /** The request has been accepted and the migration operation is being initialized. */
+    KnownMigrationProvisioningState["Accepted"] = "Accepted";
+    /** The migration operation is in progress. */
+    KnownMigrationProvisioningState["InProgress"] = "InProgress";
+    /** The migration operation has completed transferring data and is ready for DNS switch. */
+    KnownMigrationProvisioningState["ReadyForDnsSwitch"] = "ReadyForDnsSwitch";
+    /** The migration operation has completed successfully. */
+    KnownMigrationProvisioningState["Succeeded"] = "Succeeded";
+    /** The migration operation has failed. */
+    KnownMigrationProvisioningState["Failed"] = "Failed";
+    /** The migration operation is being cancelled. */
+    KnownMigrationProvisioningState["Cancelling"] = "Cancelling";
+    /** The migration operation has been cancelled. */
+    KnownMigrationProvisioningState["Cancelled"] = "Cancelled";
+    /** The migration operation cancellation has failed. */
+    KnownMigrationProvisioningState["CancellationFailed"] = "CancellationFailed";
+})(KnownMigrationProvisioningState || (KnownMigrationProvisioningState = {}));
+export function azureCacheForRedisMigrationPropertiesSerializer(item) {
+    return {
+        sourceType: item["sourceType"],
+        sourceResourceId: item["sourceResourceId"],
+        switchDns: item["switchDns"],
+        skipDataMigration: item["skipDataMigration"],
+        forceMigrate: item["forceMigrate"],
+    };
+}
+export function azureCacheForRedisMigrationPropertiesDeserializer(item) {
+    return {
+        sourceType: item["sourceType"],
+        targetResourceId: item["targetResourceId"],
+        provisioningState: item["provisioningState"],
+        statusDetails: item["statusDetails"],
+        creationTime: !item["creationTime"] ? item["creationTime"] : new Date(item["creationTime"]),
+        lastModifiedTime: !item["lastModifiedTime"]
+            ? item["lastModifiedTime"]
+            : new Date(item["lastModifiedTime"]),
+        sourceResourceId: item["sourceResourceId"],
+        switchDns: item["switchDns"],
+        skipDataMigration: item["skipDataMigration"],
+        forceMigrate: item["forceMigrate"],
+    };
+}
+export function _migrationListDeserializer(item) {
+    return {
+        value: migrationArrayDeserializer(item["value"]),
+        nextLink: item["nextLink"],
+    };
+}
+export function migrationArraySerializer(result) {
+    return result.map((item) => {
+        return migrationSerializer(item);
+    });
+}
+export function migrationArrayDeserializer(result) {
+    return result.map((item) => {
+        return migrationDeserializer(item);
+    });
+}
+export function operationStatusDeserializer(item) {
+    return {
+        id: item["id"],
+        name: item["name"],
+        startTime: item["startTime"],
+        endTime: item["endTime"],
+        status: item["status"],
+        error: !item["error"] ? item["error"] : errorResponseDeserializer(item["error"]),
+    };
+}
+/** The available API versions. */
+export var KnownVersions;
+(function (KnownVersions) {
+    /** The 2025-08-01-preview API version. */
+    KnownVersions["V20250801Preview"] = "2025-08-01-preview";
+    /** The 2026-02-01-preview API version. */
+    KnownVersions["V20260201Preview"] = "2026-02-01-preview";
+})(KnownVersions || (KnownVersions = {}));
+export function _databasePropertiesSerializer(item) {
+    return {
+        clientProtocol: item["clientProtocol"],
+        port: item["port"],
+        clusteringPolicy: item["clusteringPolicy"],
+        evictionPolicy: item["evictionPolicy"],
+        persistence: !item["persistence"]
+            ? item["persistence"]
+            : persistenceSerializer(item["persistence"]),
+        modules: !item["modules"] ? item["modules"] : moduleArraySerializer(item["modules"]),
+        geoReplication: !item["geoReplication"]
+            ? item["geoReplication"]
+            : databaseCommonPropertiesGeoReplicationSerializer(item["geoReplication"]),
+        deferUpgrade: item["deferUpgrade"],
+        accessKeysAuthentication: item["accessKeysAuthentication"],
+        notifyKeyspaceEvents: item["notifyKeyspaceEvents"],
+    };
+}
+export function _databasePropertiesDeserializer(item) {
+    return {
+        clientProtocol: item["clientProtocol"],
+        port: item["port"],
+        provisioningState: item["provisioningState"],
+        resourceState: item["resourceState"],
+        clusteringPolicy: item["clusteringPolicy"],
+        evictionPolicy: item["evictionPolicy"],
+        persistence: !item["persistence"]
+            ? item["persistence"]
+            : persistenceDeserializer(item["persistence"]),
+        modules: !item["modules"] ? item["modules"] : moduleArrayDeserializer(item["modules"]),
+        geoReplication: !item["geoReplication"]
+            ? item["geoReplication"]
+            : databaseCommonPropertiesGeoReplicationDeserializer(item["geoReplication"]),
+        redisVersion: item["redisVersion"],
+        deferUpgrade: item["deferUpgrade"],
+        accessKeysAuthentication: item["accessKeysAuthentication"],
+        notifyKeyspaceEvents: item["notifyKeyspaceEvents"],
+    };
+}
+export function _databaseUpdatePropertiesSerializer(item) {
+    return {
+        clientProtocol: item["clientProtocol"],
+        port: item["port"],
+        clusteringPolicy: item["clusteringPolicy"],
+        evictionPolicy: item["evictionPolicy"],
+        persistence: !item["persistence"]
+            ? item["persistence"]
+            : persistenceSerializer(item["persistence"]),
+        modules: !item["modules"] ? item["modules"] : moduleArraySerializer(item["modules"]),
+        geoReplication: !item["geoReplication"]
+            ? item["geoReplication"]
+            : databaseCommonPropertiesGeoReplicationSerializer(item["geoReplication"]),
+        deferUpgrade: item["deferUpgrade"],
+        accessKeysAuthentication: item["accessKeysAuthentication"],
+        notifyKeyspaceEvents: item["notifyKeyspaceEvents"],
+    };
+}
+export function _privateEndpointConnectionPropertiesSerializer(item) {
+    return {
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointSerializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateLinkServiceConnectionStateSerializer(item["privateLinkServiceConnectionState"]),
+    };
+}
+export function _privateEndpointConnectionPropertiesDeserializer(item) {
+    return {
+        groupIds: !item["groupIds"]
+            ? item["groupIds"]
+            : item["groupIds"].map((p) => {
+                return p;
+            }),
+        privateEndpoint: !item["privateEndpoint"]
+            ? item["privateEndpoint"]
+            : privateEndpointDeserializer(item["privateEndpoint"]),
+        privateLinkServiceConnectionState: !item["privateLinkServiceConnectionState"]
+            ? item["privateLinkServiceConnectionState"]
+            : privateLinkServiceConnectionStateDeserializer(item["privateLinkServiceConnectionState"]),
+        provisioningState: item["provisioningState"],
+    };
+}
+export function _clusterPropertiesSerializer(item) {
+    return {
+        highAvailability: item["highAvailability"],
+        minimumTlsVersion: item["minimumTlsVersion"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : clusterCommonPropertiesEncryptionSerializer(item["encryption"]),
+        maintenanceConfiguration: !item["maintenanceConfiguration"]
+            ? item["maintenanceConfiguration"]
+            : maintenanceConfigurationSerializer(item["maintenanceConfiguration"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+    };
+}
+export function _clusterPropertiesDeserializer(item) {
+    return {
+        highAvailability: item["highAvailability"],
+        minimumTlsVersion: item["minimumTlsVersion"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : clusterCommonPropertiesEncryptionDeserializer(item["encryption"]),
+        maintenanceConfiguration: !item["maintenanceConfiguration"]
+            ? item["maintenanceConfiguration"]
+            : maintenanceConfigurationDeserializer(item["maintenanceConfiguration"]),
+        hostName: item["hostName"],
+        provisioningState: item["provisioningState"],
+        redundancyMode: item["redundancyMode"],
+        resourceState: item["resourceState"],
+        redisVersion: item["redisVersion"],
+        privateEndpointConnections: !item["privateEndpointConnections"]
+            ? item["privateEndpointConnections"]
+            : privateEndpointConnectionArrayDeserializer(item["privateEndpointConnections"]),
+        migratedEndpoint: item["migratedEndpoint"],
+        publicNetworkAccess: item["publicNetworkAccess"],
+    };
+}
+export function _clusterUpdatePropertiesSerializer(item) {
+    return {
+        highAvailability: item["highAvailability"],
+        minimumTlsVersion: item["minimumTlsVersion"],
+        encryption: !item["encryption"]
+            ? item["encryption"]
+            : clusterCommonPropertiesEncryptionSerializer(item["encryption"]),
+        maintenanceConfiguration: !item["maintenanceConfiguration"]
+            ? item["maintenanceConfiguration"]
+            : maintenanceConfigurationSerializer(item["maintenanceConfiguration"]),
+        publicNetworkAccess: item["publicNetworkAccess"],
+    };
+}
+export function _privateLinkResourcePropertiesDeserializer(item) {
+    return {
+        groupId: item["groupId"],
+        requiredMembers: !item["requiredMembers"]
+            ? item["requiredMembers"]
+            : item["requiredMembers"].map((p) => {
+                return p;
+            }),
+        requiredZoneNames: !item["requiredZoneNames"]
+            ? item["requiredZoneNames"]
+            : item["requiredZoneNames"].map((p) => {
+                return p;
+            }),
+    };
+}
+export function _accessPolicyAssignmentPropertiesSerializer(item) {
+    return {
+        accessPolicyName: item["accessPolicyName"],
+        user: !item["user"]
+            ? item["user"]
+            : accessPolicyAssignmentPropertiesUserSerializer(item["user"]),
+    };
+}
+export function _accessPolicyAssignmentPropertiesDeserializer(item) {
+    return {
+        provisioningState: item["provisioningState"],
+        accessPolicyName: item["accessPolicyName"],
+        user: !item["user"]
+            ? item["user"]
+            : accessPolicyAssignmentPropertiesUserDeserializer(item["user"]),
+    };
+}
+//# sourceMappingURL=models.js.map