## API Report File for "@azure/arm-rediscache"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import * as coreAuth from '@azure/core-auth';
import * as coreClient from '@azure/core-client';
import { OperationState } from '@azure/core-lro';
import { PagedAsyncIterableIterator } from '@azure/core-paging';
import { SimplePollerLike } from '@azure/core-lro';

// @public
export interface AccessPolicy {
    beginCreateUpdate(resourceGroupName: string, cacheName: string, accessPolicyName: string, parameters: RedisCacheAccessPolicy, options?: AccessPolicyCreateUpdateOptionalParams): Promise<SimplePollerLike<OperationState<AccessPolicyCreateUpdateResponse>, AccessPolicyCreateUpdateResponse>>;
    beginCreateUpdateAndWait(resourceGroupName: string, cacheName: string, accessPolicyName: string, parameters: RedisCacheAccessPolicy, options?: AccessPolicyCreateUpdateOptionalParams): Promise<AccessPolicyCreateUpdateResponse>;
    beginDelete(resourceGroupName: string, cacheName: string, accessPolicyName: string, options?: AccessPolicyDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, cacheName: string, accessPolicyName: string, options?: AccessPolicyDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, cacheName: string, accessPolicyName: string, options?: AccessPolicyGetOptionalParams): Promise<AccessPolicyGetResponse>;
    list(resourceGroupName: string, cacheName: string, options?: AccessPolicyListOptionalParams): PagedAsyncIterableIterator<RedisCacheAccessPolicy>;
}

// @public
export interface AccessPolicyAssignment {
    beginCreateUpdate(resourceGroupName: string, cacheName: string, accessPolicyAssignmentName: string, parameters: RedisCacheAccessPolicyAssignment, options?: AccessPolicyAssignmentCreateUpdateOptionalParams): Promise<SimplePollerLike<OperationState<AccessPolicyAssignmentCreateUpdateResponse>, AccessPolicyAssignmentCreateUpdateResponse>>;
    beginCreateUpdateAndWait(resourceGroupName: string, cacheName: string, accessPolicyAssignmentName: string, parameters: RedisCacheAccessPolicyAssignment, options?: AccessPolicyAssignmentCreateUpdateOptionalParams): Promise<AccessPolicyAssignmentCreateUpdateResponse>;
    beginDelete(resourceGroupName: string, cacheName: string, accessPolicyAssignmentName: string, options?: AccessPolicyAssignmentDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, cacheName: string, accessPolicyAssignmentName: string, options?: AccessPolicyAssignmentDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, cacheName: string, accessPolicyAssignmentName: string, options?: AccessPolicyAssignmentGetOptionalParams): Promise<AccessPolicyAssignmentGetResponse>;
    list(resourceGroupName: string, cacheName: string, options?: AccessPolicyAssignmentListOptionalParams): PagedAsyncIterableIterator<RedisCacheAccessPolicyAssignment>;
}

// @public
export interface AccessPolicyAssignmentCreateUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AccessPolicyAssignmentCreateUpdateResponse = RedisCacheAccessPolicyAssignment;

// @public
export interface AccessPolicyAssignmentDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface AccessPolicyAssignmentDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface AccessPolicyAssignmentGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AccessPolicyAssignmentGetResponse = RedisCacheAccessPolicyAssignment;

// @public
export interface AccessPolicyAssignmentListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AccessPolicyAssignmentListNextResponse = RedisCacheAccessPolicyAssignmentList;

// @public
export interface AccessPolicyAssignmentListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AccessPolicyAssignmentListResponse = RedisCacheAccessPolicyAssignmentList;

// @public
export type AccessPolicyAssignmentProvisioningState = string;

// @public
export interface AccessPolicyCreateUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type AccessPolicyCreateUpdateResponse = RedisCacheAccessPolicy;

// @public
export interface AccessPolicyDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface AccessPolicyDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface AccessPolicyGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AccessPolicyGetResponse = RedisCacheAccessPolicy;

// @public
export interface AccessPolicyListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AccessPolicyListNextResponse = RedisCacheAccessPolicyList;

// @public
export interface AccessPolicyListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AccessPolicyListResponse = RedisCacheAccessPolicyList;

// @public
export type AccessPolicyProvisioningState = string;

// @public
export type AccessPolicyType = string;

// @public
export interface AsyncOperationStatus {
    get(location: string, operationId: string, options?: AsyncOperationStatusGetOptionalParams): Promise<AsyncOperationStatusGetResponse>;
}

// @public
export interface AsyncOperationStatusGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type AsyncOperationStatusGetResponse = OperationStatus;

// @public
export interface CheckNameAvailabilityParameters {
    name: string;
    type: string;
}

// @public
export type DayOfWeek = "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "Sunday" | "Everyday" | "Weekend";

// @public
export type DefaultName = string;

// @public
export interface ErrorAdditionalInfo {
    readonly info?: Record<string, unknown>;
    readonly type?: string;
}

// @public
export interface ErrorDetail {
    readonly additionalInfo?: ErrorAdditionalInfo[];
    readonly code?: string;
    readonly details?: ErrorDetail[];
    readonly message?: string;
    readonly target?: string;
}

// @public
export interface ErrorResponse {
    error?: ErrorDetail;
}

// @public
export interface ExportRDBParameters {
    container: string;
    format?: string;
    preferredDataArchiveAuthMethod?: string;
    prefix: string;
    storageSubscriptionId?: string;
}

// @public
export interface FirewallRules {
    createOrUpdate(resourceGroupName: string, cacheName: string, ruleName: string, parameters: RedisFirewallRule, options?: FirewallRulesCreateOrUpdateOptionalParams): Promise<FirewallRulesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, cacheName: string, ruleName: string, options?: FirewallRulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, cacheName: string, ruleName: string, options?: FirewallRulesGetOptionalParams): Promise<FirewallRulesGetResponse>;
    list(resourceGroupName: string, cacheName: string, options?: FirewallRulesListOptionalParams): PagedAsyncIterableIterator<RedisFirewallRule>;
}

// @public
export interface FirewallRulesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type FirewallRulesCreateOrUpdateResponse = RedisFirewallRule;

// @public
export interface FirewallRulesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface FirewallRulesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type FirewallRulesGetResponse = RedisFirewallRule;

// @public
export interface FirewallRulesListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type FirewallRulesListNextResponse = RedisFirewallRuleListResult;

// @public
export interface FirewallRulesListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type FirewallRulesListResponse = RedisFirewallRuleListResult;

// @public
export function getContinuationToken(page: unknown): string | undefined;

// @public
export interface ImportRDBParameters {
    files: string[];
    format?: string;
    preferredDataArchiveAuthMethod?: string;
    storageSubscriptionId?: string;
}

// @public
export enum KnownAccessPolicyAssignmentProvisioningState {
    Canceled = "Canceled",
    Deleted = "Deleted",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownAccessPolicyProvisioningState {
    Canceled = "Canceled",
    Deleted = "Deleted",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded",
    Updating = "Updating"
}

// @public
export enum KnownAccessPolicyType {
    BuiltIn = "BuiltIn",
    Custom = "Custom"
}

// @public
export enum KnownDefaultName {
    Default = "default"
}

// @public
export enum KnownManagedServiceIdentityType {
    None = "None",
    SystemAssigned = "SystemAssigned",
    SystemAssignedUserAssigned = "SystemAssigned, UserAssigned",
    UserAssigned = "UserAssigned"
}

// @public
export enum KnownPrivateEndpointConnectionProvisioningState {
    Creating = "Creating",
    Deleting = "Deleting",
    Failed = "Failed",
    Succeeded = "Succeeded"
}

// @public
export enum KnownPrivateEndpointServiceConnectionStatus {
    Approved = "Approved",
    Pending = "Pending",
    Rejected = "Rejected"
}

// @public
export enum KnownProvisioningState {
    ConfiguringAAD = "ConfiguringAAD",
    Creating = "Creating",
    Deleting = "Deleting",
    Disabled = "Disabled",
    Failed = "Failed",
    Linking = "Linking",
    Provisioning = "Provisioning",
    RecoveringScaleFailure = "RecoveringScaleFailure",
    Scaling = "Scaling",
    Succeeded = "Succeeded",
    Unlinking = "Unlinking",
    Unprovisioning = "Unprovisioning",
    Updating = "Updating"
}

// @public
export enum KnownPublicNetworkAccess {
    Disabled = "Disabled",
    Enabled = "Enabled"
}

// @public
export enum KnownRebootType {
    AllNodes = "AllNodes",
    PrimaryNode = "PrimaryNode",
    SecondaryNode = "SecondaryNode"
}

// @public
export enum KnownSkuFamily {
    // (undocumented)
    C = "C",
    // (undocumented)
    P = "P"
}

// @public
export enum KnownSkuName {
    Basic = "Basic",
    Premium = "Premium",
    Standard = "Standard"
}

// @public
export enum KnownTlsVersion {
    One0 = "1.0",
    One1 = "1.1",
    One2 = "1.2"
}

// @public
export enum KnownUpdateChannel {
    Preview = "Preview",
    Stable = "Stable"
}

// @public
export enum KnownZonalAllocationPolicy {
    Automatic = "Automatic",
    NoZones = "NoZones",
    UserDefined = "UserDefined"
}

// @public
export interface LinkedServer {
    beginCreate(resourceGroupName: string, name: string, linkedServerName: string, parameters: RedisLinkedServerCreateParameters, options?: LinkedServerCreateOptionalParams): Promise<SimplePollerLike<OperationState<LinkedServerCreateResponse>, LinkedServerCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, name: string, linkedServerName: string, parameters: RedisLinkedServerCreateParameters, options?: LinkedServerCreateOptionalParams): Promise<LinkedServerCreateResponse>;
    beginDelete(resourceGroupName: string, name: string, linkedServerName: string, options?: LinkedServerDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, name: string, linkedServerName: string, options?: LinkedServerDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, linkedServerName: string, options?: LinkedServerGetOptionalParams): Promise<LinkedServerGetResponse>;
    list(resourceGroupName: string, name: string, options?: LinkedServerListOptionalParams): PagedAsyncIterableIterator<RedisLinkedServerWithProperties>;
}

// @public
export interface LinkedServerCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type LinkedServerCreateResponse = RedisLinkedServerWithProperties;

// @public
export interface LinkedServerDeleteHeaders {
    // (undocumented)
    location?: string;
}

// @public
export interface LinkedServerDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface LinkedServerGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type LinkedServerGetResponse = RedisLinkedServerWithProperties;

// @public
export interface LinkedServerListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type LinkedServerListNextResponse = RedisLinkedServerWithPropertiesList;

// @public
export interface LinkedServerListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type LinkedServerListResponse = RedisLinkedServerWithPropertiesList;

// @public
export interface ManagedServiceIdentity {
    readonly principalId?: string;
    readonly tenantId?: string;
    type: ManagedServiceIdentityType;
    userAssignedIdentities?: {
        [propertyName: string]: UserAssignedIdentity;
    };
}

// @public
export type ManagedServiceIdentityType = string;

// @public
export interface NotificationListResponse {
    readonly nextLink?: string;
    value?: UpgradeNotification[];
}

// @public
export interface Operation {
    display?: OperationDisplay;
    name?: string;
}

// @public
export interface OperationDisplay {
    description?: string;
    operation?: string;
    provider?: string;
    resource?: string;
}

// @public
export interface OperationListResult {
    readonly nextLink?: string;
    value?: Operation[];
}

// @public
export interface Operations {
    list(options?: OperationsListOptionalParams): PagedAsyncIterableIterator<Operation>;
}

// @public
export interface OperationsListNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type OperationsListNextResponse = OperationListResult;

// @public
export interface OperationsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type OperationsListResponse = OperationListResult;

// @public
export interface OperationStatus extends OperationStatusResult {
    properties?: {
        [propertyName: string]: any;
    };
}

// @public
export interface OperationStatusResult {
    endTime?: Date;
    error?: ErrorDetail;
    id?: string;
    name?: string;
    operations?: OperationStatusResult[];
    percentComplete?: number;
    startTime?: Date;
    status: string;
}

// @public
export interface PatchSchedules {
    createOrUpdate(resourceGroupName: string, name: string, defaultParam: DefaultName, parameters: RedisPatchSchedule, options?: PatchSchedulesCreateOrUpdateOptionalParams): Promise<PatchSchedulesCreateOrUpdateResponse>;
    delete(resourceGroupName: string, name: string, defaultParam: DefaultName, options?: PatchSchedulesDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, name: string, defaultParam: DefaultName, options?: PatchSchedulesGetOptionalParams): Promise<PatchSchedulesGetResponse>;
    listByRedisResource(resourceGroupName: string, cacheName: string, options?: PatchSchedulesListByRedisResourceOptionalParams): PagedAsyncIterableIterator<RedisPatchSchedule>;
}

// @public
export interface PatchSchedulesCreateOrUpdateOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PatchSchedulesCreateOrUpdateResponse = RedisPatchSchedule;

// @public
export interface PatchSchedulesDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface PatchSchedulesGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PatchSchedulesGetResponse = RedisPatchSchedule;

// @public
export interface PatchSchedulesListByRedisResourceNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PatchSchedulesListByRedisResourceNextResponse = RedisPatchScheduleListResult;

// @public
export interface PatchSchedulesListByRedisResourceOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PatchSchedulesListByRedisResourceResponse = RedisPatchScheduleListResult;

// @public
export interface PrivateEndpoint {
    readonly id?: string;
}

// @public
export interface PrivateEndpointConnection extends Resource {
    privateEndpoint?: PrivateEndpoint;
    privateLinkServiceConnectionState?: PrivateLinkServiceConnectionState;
    readonly provisioningState?: PrivateEndpointConnectionProvisioningState;
}

// @public
export interface PrivateEndpointConnectionListResult {
    value?: PrivateEndpointConnection[];
}

// @public
export type PrivateEndpointConnectionProvisioningState = string;

// @public
export interface PrivateEndpointConnections {
    beginPut(resourceGroupName: string, cacheName: string, privateEndpointConnectionName: string, properties: PrivateEndpointConnection, options?: PrivateEndpointConnectionsPutOptionalParams): Promise<SimplePollerLike<OperationState<PrivateEndpointConnectionsPutResponse>, PrivateEndpointConnectionsPutResponse>>;
    beginPutAndWait(resourceGroupName: string, cacheName: string, privateEndpointConnectionName: string, properties: PrivateEndpointConnection, options?: PrivateEndpointConnectionsPutOptionalParams): Promise<PrivateEndpointConnectionsPutResponse>;
    delete(resourceGroupName: string, cacheName: string, privateEndpointConnectionName: string, options?: PrivateEndpointConnectionsDeleteOptionalParams): Promise<void>;
    get(resourceGroupName: string, cacheName: string, privateEndpointConnectionName: string, options?: PrivateEndpointConnectionsGetOptionalParams): Promise<PrivateEndpointConnectionsGetResponse>;
    list(resourceGroupName: string, cacheName: string, options?: PrivateEndpointConnectionsListOptionalParams): PagedAsyncIterableIterator<PrivateEndpointConnection>;
}

// @public
export interface PrivateEndpointConnectionsDeleteOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface PrivateEndpointConnectionsGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateEndpointConnectionsGetResponse = PrivateEndpointConnection;

// @public
export interface PrivateEndpointConnectionsListOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateEndpointConnectionsListResponse = PrivateEndpointConnectionListResult;

// @public
export interface PrivateEndpointConnectionsPutOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type PrivateEndpointConnectionsPutResponse = PrivateEndpointConnection;

// @public
export type PrivateEndpointServiceConnectionStatus = string;

// @public
export interface PrivateLinkResource extends Resource {
    readonly groupId?: string;
    readonly requiredMembers?: string[];
    requiredZoneNames?: string[];
}

// @public
export interface PrivateLinkResourceListResult {
    value?: PrivateLinkResource[];
}

// @public
export interface PrivateLinkResources {
    listByRedisCache(resourceGroupName: string, cacheName: string, options?: PrivateLinkResourcesListByRedisCacheOptionalParams): PagedAsyncIterableIterator<PrivateLinkResource>;
}

// @public
export interface PrivateLinkResourcesListByRedisCacheOptionalParams extends coreClient.OperationOptions {
}

// @public
export type PrivateLinkResourcesListByRedisCacheResponse = PrivateLinkResourceListResult;

// @public
export interface PrivateLinkServiceConnectionState {
    actionsRequired?: string;
    description?: string;
    status?: PrivateEndpointServiceConnectionStatus;
}

// @public
export type ProvisioningState = string;

// @public
export interface ProxyResource extends Resource {
}

// @public
export type PublicNetworkAccess = string;

// @public
export type RebootType = string;

// @public
export interface Redis {
    beginCreate(resourceGroupName: string, name: string, parameters: RedisCreateParameters, options?: RedisCreateOptionalParams): Promise<SimplePollerLike<OperationState<RedisCreateResponse>, RedisCreateResponse>>;
    beginCreateAndWait(resourceGroupName: string, name: string, parameters: RedisCreateParameters, options?: RedisCreateOptionalParams): Promise<RedisCreateResponse>;
    beginDelete(resourceGroupName: string, name: string, options?: RedisDeleteOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginDeleteAndWait(resourceGroupName: string, name: string, options?: RedisDeleteOptionalParams): Promise<void>;
    beginExportData(resourceGroupName: string, name: string, parameters: ExportRDBParameters, options?: RedisExportDataOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginExportDataAndWait(resourceGroupName: string, name: string, parameters: ExportRDBParameters, options?: RedisExportDataOptionalParams): Promise<void>;
    beginFlushCache(resourceGroupName: string, cacheName: string, options?: RedisFlushCacheOptionalParams): Promise<SimplePollerLike<OperationState<RedisFlushCacheResponse>, RedisFlushCacheResponse>>;
    beginFlushCacheAndWait(resourceGroupName: string, cacheName: string, options?: RedisFlushCacheOptionalParams): Promise<RedisFlushCacheResponse>;
    beginImportData(resourceGroupName: string, name: string, parameters: ImportRDBParameters, options?: RedisImportDataOptionalParams): Promise<SimplePollerLike<OperationState<void>, void>>;
    beginImportDataAndWait(resourceGroupName: string, name: string, parameters: ImportRDBParameters, options?: RedisImportDataOptionalParams): Promise<void>;
    beginUpdate(resourceGroupName: string, name: string, parameters: RedisUpdateParameters, options?: RedisUpdateOptionalParams): Promise<SimplePollerLike<OperationState<RedisUpdateResponse>, RedisUpdateResponse>>;
    beginUpdateAndWait(resourceGroupName: string, name: string, parameters: RedisUpdateParameters, options?: RedisUpdateOptionalParams): Promise<RedisUpdateResponse>;
    checkNameAvailability(parameters: CheckNameAvailabilityParameters, options?: RedisCheckNameAvailabilityOptionalParams): Promise<void>;
    forceReboot(resourceGroupName: string, name: string, parameters: RedisRebootParameters, options?: RedisForceRebootOptionalParams): Promise<RedisForceRebootOperationResponse>;
    get(resourceGroupName: string, name: string, options?: RedisGetOptionalParams): Promise<RedisGetResponse>;
    listByResourceGroup(resourceGroupName: string, options?: RedisListByResourceGroupOptionalParams): PagedAsyncIterableIterator<RedisResource>;
    listBySubscription(options?: RedisListBySubscriptionOptionalParams): PagedAsyncIterableIterator<RedisResource>;
    listKeys(resourceGroupName: string, name: string, options?: RedisListKeysOptionalParams): Promise<RedisListKeysResponse>;
    listUpgradeNotifications(resourceGroupName: string, name: string, history: number, options?: RedisListUpgradeNotificationsOptionalParams): PagedAsyncIterableIterator<UpgradeNotification>;
    regenerateKey(resourceGroupName: string, name: string, parameters: RedisRegenerateKeyParameters, options?: RedisRegenerateKeyOptionalParams): Promise<RedisRegenerateKeyResponse>;
}

// @public
export interface RedisAccessKeys {
    readonly primaryKey?: string;
    readonly secondaryKey?: string;
}

// @public
export interface RedisCacheAccessPolicy extends ProxyResource {
    permissions?: string;
    readonly provisioningState?: AccessPolicyProvisioningState;
    readonly typePropertiesType?: AccessPolicyType;
}

// @public
export interface RedisCacheAccessPolicyAssignment extends ProxyResource {
    accessPolicyName?: string;
    objectId?: string;
    objectIdAlias?: string;
    readonly provisioningState?: AccessPolicyAssignmentProvisioningState;
}

// @public
export interface RedisCacheAccessPolicyAssignmentList {
    readonly nextLink?: string;
    value?: RedisCacheAccessPolicyAssignment[];
}

// @public
export interface RedisCacheAccessPolicyList {
    readonly nextLink?: string;
    value?: RedisCacheAccessPolicy[];
}

// @public
export interface RedisCheckNameAvailabilityOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RedisCommonProperties {
    disableAccessKeyAuthentication?: boolean;
    enableNonSslPort?: boolean;
    minimumTlsVersion?: TlsVersion;
    publicNetworkAccess?: PublicNetworkAccess;
    redisConfiguration?: RedisCommonPropertiesRedisConfiguration;
    redisVersion?: string;
    replicasPerMaster?: number;
    replicasPerPrimary?: number;
    shardCount?: number;
    tenantSettings?: {
        [propertyName: string]: string;
    };
    updateChannel?: UpdateChannel;
    zonalAllocationPolicy?: ZonalAllocationPolicy;
}

// @public
export interface RedisCommonPropertiesRedisConfiguration {
    [property: string]: any;
    aadEnabled?: string;
    aofBackupEnabled?: string;
    aofStorageConnectionString0?: string;
    aofStorageConnectionString1?: string;
    authnotrequired?: string;
    readonly maxclients?: string;
    maxfragmentationmemoryReserved?: string;
    maxmemoryDelta?: string;
    maxmemoryPolicy?: string;
    maxmemoryReserved?: string;
    notifyKeyspaceEvents?: string;
    readonly preferredDataArchiveAuthMethod?: string;
    preferredDataPersistenceAuthMethod?: string;
    rdbBackupEnabled?: string;
    rdbBackupFrequency?: string;
    rdbBackupMaxSnapshotCount?: string;
    rdbStorageConnectionString?: string;
    storageSubscriptionId?: string;
    readonly zonalConfiguration?: string;
}

// @public
export interface RedisCreateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface RedisCreateParameters {
    disableAccessKeyAuthentication?: boolean;
    enableNonSslPort?: boolean;
    identity?: ManagedServiceIdentity;
    location: string;
    minimumTlsVersion?: TlsVersion;
    publicNetworkAccess?: PublicNetworkAccess;
    redisConfiguration?: RedisCommonPropertiesRedisConfiguration;
    redisVersion?: string;
    replicasPerMaster?: number;
    replicasPerPrimary?: number;
    shardCount?: number;
    sku: Sku;
    staticIP?: string;
    subnetId?: string;
    tags?: {
        [propertyName: string]: string;
    };
    tenantSettings?: {
        [propertyName: string]: string;
    };
    updateChannel?: UpdateChannel;
    zonalAllocationPolicy?: ZonalAllocationPolicy;
    zones?: string[];
}

// @public
export interface RedisCreateProperties extends RedisCommonProperties {
    sku: Sku;
    staticIP?: string;
    subnetId?: string;
}

// @public
export type RedisCreateResponse = RedisResource;

// @public
export interface RedisDeleteOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface RedisExportDataOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface RedisFirewallRule extends ProxyResource {
    endIP: string;
    startIP: string;
}

// @public
export interface RedisFirewallRuleCreateParameters extends RedisFirewallRule {
}

// @public
export interface RedisFirewallRuleListResult {
    readonly nextLink?: string;
    value?: RedisFirewallRule[];
}

// @public
export interface RedisFlushCacheHeaders {
    azureAsyncOperation?: string;
    location?: string;
}

// @public
export interface RedisFlushCacheOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export type RedisFlushCacheResponse = RedisFlushCacheHeaders & OperationStatusResult;

// @public
export type RedisForceRebootOperationResponse = RedisForceRebootResponse;

// @public
export interface RedisForceRebootOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RedisForceRebootResponse {
    readonly message?: string;
}

// @public
export interface RedisGetOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RedisGetResponse = RedisResource;

// @public
export interface RedisImportDataOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface RedisInstanceDetails {
    readonly isMaster?: boolean;
    readonly isPrimary?: boolean;
    readonly nonSslPort?: number;
    readonly shardId?: number;
    readonly sslPort?: number;
    readonly zone?: string;
}

// @public
export type RedisKeyType = "Primary" | "Secondary";

// @public
export interface RedisLinkedServer {
    readonly id?: string;
}

// @public
export interface RedisLinkedServerCreateParameters {
    readonly geoReplicatedPrimaryHostName?: string;
    linkedRedisCacheId: string;
    linkedRedisCacheLocation: string;
    readonly primaryHostName?: string;
    serverRole: ReplicationRole;
}

// @public
export interface RedisLinkedServerCreateProperties {
    readonly geoReplicatedPrimaryHostName?: string;
    linkedRedisCacheId: string;
    linkedRedisCacheLocation: string;
    readonly primaryHostName?: string;
    serverRole: ReplicationRole;
}

// @public
export interface RedisLinkedServerProperties extends RedisLinkedServerCreateProperties {
    readonly provisioningState?: string;
}

// @public
export interface RedisLinkedServerWithProperties extends ProxyResource {
    readonly geoReplicatedPrimaryHostName?: string;
    linkedRedisCacheId?: string;
    linkedRedisCacheLocation?: string;
    readonly primaryHostName?: string;
    readonly provisioningState?: string;
    serverRole?: ReplicationRole;
}

// @public
export interface RedisLinkedServerWithPropertiesList {
    readonly nextLink?: string;
    value?: RedisLinkedServerWithProperties[];
}

// @public
export interface RedisListByResourceGroupNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RedisListByResourceGroupNextResponse = RedisListResult;

// @public
export interface RedisListByResourceGroupOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RedisListByResourceGroupResponse = RedisListResult;

// @public
export interface RedisListBySubscriptionNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RedisListBySubscriptionNextResponse = RedisListResult;

// @public
export interface RedisListBySubscriptionOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RedisListBySubscriptionResponse = RedisListResult;

// @public
export interface RedisListKeysOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RedisListKeysResponse = RedisAccessKeys;

// @public
export interface RedisListResult {
    readonly nextLink?: string;
    value?: RedisResource[];
}

// @public
export interface RedisListUpgradeNotificationsNextOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RedisListUpgradeNotificationsNextResponse = NotificationListResponse;

// @public
export interface RedisListUpgradeNotificationsOptionalParams extends coreClient.OperationOptions {
}

// @public
export type RedisListUpgradeNotificationsResponse = NotificationListResponse;

// @public (undocumented)
export class RedisManagementClient extends coreClient.ServiceClient {
    // (undocumented)
    $host: string;
    constructor(credentials: coreAuth.TokenCredential, subscriptionId: string, options?: RedisManagementClientOptionalParams);
    // (undocumented)
    accessPolicy: AccessPolicy;
    // (undocumented)
    accessPolicyAssignment: AccessPolicyAssignment;
    // (undocumented)
    apiVersion: string;
    // (undocumented)
    asyncOperationStatus: AsyncOperationStatus;
    // (undocumented)
    firewallRules: FirewallRules;
    // (undocumented)
    linkedServer: LinkedServer;
    // (undocumented)
    operations: Operations;
    // (undocumented)
    patchSchedules: PatchSchedules;
    // (undocumented)
    privateEndpointConnections: PrivateEndpointConnections;
    // (undocumented)
    privateLinkResources: PrivateLinkResources;
    // (undocumented)
    redis: Redis;
    // (undocumented)
    subscriptionId: string;
}

// @public
export interface RedisManagementClientOptionalParams extends coreClient.ServiceClientOptions {
    $host?: string;
    apiVersion?: string;
    endpoint?: string;
}

// @public
export interface RedisPatchSchedule extends ProxyResource {
    readonly location?: string;
    scheduleEntries: ScheduleEntry[];
}

// @public
export interface RedisPatchScheduleListResult {
    readonly nextLink?: string;
    value?: RedisPatchSchedule[];
}

// @public
export interface RedisProperties extends RedisCreateProperties {
    readonly accessKeys?: RedisAccessKeys;
    readonly hostName?: string;
    readonly instances?: RedisInstanceDetails[];
    readonly linkedServers?: RedisLinkedServer[];
    readonly port?: number;
    readonly privateEndpointConnections?: PrivateEndpointConnection[];
    readonly provisioningState?: ProvisioningState;
    readonly sslPort?: number;
}

// @public
export interface RedisRebootParameters {
    ports?: number[];
    rebootType?: RebootType;
    shardId?: number;
}

// @public
export interface RedisRegenerateKeyOptionalParams extends coreClient.OperationOptions {
}

// @public
export interface RedisRegenerateKeyParameters {
    keyType: RedisKeyType;
}

// @public
export type RedisRegenerateKeyResponse = RedisAccessKeys;

// @public
export interface RedisResource extends TrackedResource {
    readonly accessKeys?: RedisAccessKeys;
    disableAccessKeyAuthentication?: boolean;
    enableNonSslPort?: boolean;
    readonly hostName?: string;
    identity?: ManagedServiceIdentity;
    readonly instances?: RedisInstanceDetails[];
    readonly linkedServers?: RedisLinkedServer[];
    minimumTlsVersion?: TlsVersion;
    readonly port?: number;
    readonly privateEndpointConnections?: PrivateEndpointConnection[];
    readonly provisioningState?: ProvisioningState;
    publicNetworkAccess?: PublicNetworkAccess;
    redisConfiguration?: RedisCommonPropertiesRedisConfiguration;
    redisVersion?: string;
    replicasPerMaster?: number;
    replicasPerPrimary?: number;
    shardCount?: number;
    sku: Sku;
    readonly sslPort?: number;
    staticIP?: string;
    subnetId?: string;
    tenantSettings?: {
        [propertyName: string]: string;
    };
    updateChannel?: UpdateChannel;
    zonalAllocationPolicy?: ZonalAllocationPolicy;
    zones?: string[];
}

// @public
export interface RedisUpdateOptionalParams extends coreClient.OperationOptions {
    resumeFrom?: string;
    updateIntervalInMs?: number;
}

// @public
export interface RedisUpdateParameters {
    disableAccessKeyAuthentication?: boolean;
    enableNonSslPort?: boolean;
    identity?: ManagedServiceIdentity;
    minimumTlsVersion?: TlsVersion;
    publicNetworkAccess?: PublicNetworkAccess;
    redisConfiguration?: RedisCommonPropertiesRedisConfiguration;
    redisVersion?: string;
    replicasPerMaster?: number;
    replicasPerPrimary?: number;
    shardCount?: number;
    sku?: Sku;
    tags?: {
        [propertyName: string]: string;
    };
    tenantSettings?: {
        [propertyName: string]: string;
    };
    updateChannel?: UpdateChannel;
    zonalAllocationPolicy?: ZonalAllocationPolicy;
}

// @public
export interface RedisUpdateProperties extends RedisCommonProperties {
    sku?: Sku;
}

// @public
export type RedisUpdateResponse = RedisResource;

// @public
export type ReplicationRole = "Primary" | "Secondary";

// @public
export interface Resource {
    readonly id?: string;
    readonly name?: string;
    readonly type?: string;
}

// @public
export interface ScheduleEntry {
    dayOfWeek: DayOfWeek;
    maintenanceWindow?: string;
    startHourUtc: number;
}

// @public
export interface Sku {
    capacity: number;
    family: SkuFamily;
    name: SkuName;
}

// @public
export type SkuFamily = string;

// @public
export type SkuName = string;

// @public
export type TlsVersion = string;

// @public
export interface TrackedResource extends Resource {
    location: string;
    tags?: {
        [propertyName: string]: string;
    };
}

// @public
export type UpdateChannel = string;

// @public
export interface UpgradeNotification {
    readonly name?: string;
    readonly timestamp?: Date;
    readonly upsellNotification?: {
        [propertyName: string]: string;
    };
}

// @public
export interface UserAssignedIdentity {
    readonly clientId?: string;
    readonly principalId?: string;
}

// @public
export type ZonalAllocationPolicy = string;

// (No @packageDocumentation comment for this package)

```