text:
import { ServiceClientOptions, RequestOptions, ServiceCallback, HttpOperationResponse } from 'ms-rest';
import * as models from '../models';

/**
 * @class
 * Operations
 * __NOTE__: An instance of this class is automatically created for an
 * instance of the RedisManagementClient.
 */
export interface Operations {

    /**
     * Lists all of the available REST API operations of the Microsoft.Cache
     * provider.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<OperationListResult>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listWithHttpOperationResponse(options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.OperationListResult>>;

    /**
     * Lists all of the available REST API operations of the Microsoft.Cache
     * provider.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {OperationListResult} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {OperationListResult} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link OperationListResult} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    list(options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.OperationListResult>;
    list(callback: ServiceCallback<models.OperationListResult>): void;
    list(options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.OperationListResult>): void;

    /**
     * Lists all of the available REST API operations of the Microsoft.Cache
     * provider.
     *
     * @param {string} nextPageLink The NextLink from the previous successful call
     * to List operation.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<OperationListResult>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listNextWithHttpOperationResponse(nextPageLink: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.OperationListResult>>;

    /**
     * Lists all of the available REST API operations of the Microsoft.Cache
     * provider.
     *
     * @param {string} nextPageLink The NextLink from the previous successful call
     * to List operation.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {OperationListResult} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {OperationListResult} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link OperationListResult} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    listNext(nextPageLink: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.OperationListResult>;
    listNext(nextPageLink: string, callback: ServiceCallback<models.OperationListResult>): void;
    listNext(nextPageLink: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.OperationListResult>): void;
}

/**
 * @class
 * Redis
 * __NOTE__: An instance of this class is automatically created for an
 * instance of the RedisManagementClient.
 */
export interface Redis {

    /**
     * Create or replace (overwrite/recreate, with potential downtime) an existing
     * Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters supplied to the Create Redis
     * operation.
     *
     * @param {object} [parameters.redisConfiguration] All Redis Settings. Few
     * possible keys:
     * rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
     * etc.
     *
     * @param {boolean} [parameters.enableNonSslPort] Specifies whether the non-ssl
     * Redis server port (6379) is enabled.
     *
     * @param {object} [parameters.tenantSettings] tenantSettings
     *
     * @param {number} [parameters.shardCount] The number of shards to be created
     * on a Premium Cluster Cache.
     *
     * @param {string} [parameters.subnetId] The full resource ID of a subnet in a
     * virtual network to deploy the Redis cache in. Example format:
     * /subscriptions/{subid}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
     *
     * @param {string} [parameters.staticIP] Static IP address. Required when
     * deploying a Redis cache inside an existing Azure Virtual Network.
     *
     * @param {object} parameters.sku The SKU of the Redis cache to deploy.
     *
     * @param {string} parameters.sku.name The type of Redis cache to deploy. Valid
     * values: (Basic, Standard, Premium). Possible values include: 'Basic',
     * 'Standard', 'Premium'
     *
     * @param {string} parameters.sku.family The SKU family to use. Valid values:
     * (C, P). (C = Basic/Standard, P = Premium). Possible values include: 'C', 'P'
     *
     * @param {number} parameters.sku.capacity The size of the Redis cache to
     * deploy. Valid values: for C (Basic/Standard) family (0, 1, 2, 3, 4, 5, 6),
     * for P (Premium) family (1, 2, 3, 4).
     *
     * @param {string} parameters.location Resource location.
     *
     * @param {object} [parameters.tags] Resource tags.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisResource>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    createWithHttpOperationResponse(resourceGroupName: string, name: string, parameters: models.RedisCreateParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisResource>>;

    /**
     * Create or replace (overwrite/recreate, with potential downtime) an existing
     * Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters supplied to the Create Redis
     * operation.
     *
     * @param {object} [parameters.redisConfiguration] All Redis Settings. Few
     * possible keys:
     * rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
     * etc.
     *
     * @param {boolean} [parameters.enableNonSslPort] Specifies whether the non-ssl
     * Redis server port (6379) is enabled.
     *
     * @param {object} [parameters.tenantSettings] tenantSettings
     *
     * @param {number} [parameters.shardCount] The number of shards to be created
     * on a Premium Cluster Cache.
     *
     * @param {string} [parameters.subnetId] The full resource ID of a subnet in a
     * virtual network to deploy the Redis cache in. Example format:
     * /subscriptions/{subid}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
     *
     * @param {string} [parameters.staticIP] Static IP address. Required when
     * deploying a Redis cache inside an existing Azure Virtual Network.
     *
     * @param {object} parameters.sku The SKU of the Redis cache to deploy.
     *
     * @param {string} parameters.sku.name The type of Redis cache to deploy. Valid
     * values: (Basic, Standard, Premium). Possible values include: 'Basic',
     * 'Standard', 'Premium'
     *
     * @param {string} parameters.sku.family The SKU family to use. Valid values:
     * (C, P). (C = Basic/Standard, P = Premium). Possible values include: 'C', 'P'
     *
     * @param {number} parameters.sku.capacity The size of the Redis cache to
     * deploy. Valid values: for C (Basic/Standard) family (0, 1, 2, 3, 4, 5, 6),
     * for P (Premium) family (1, 2, 3, 4).
     *
     * @param {string} parameters.location Resource location.
     *
     * @param {object} [parameters.tags] Resource tags.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisResource} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisResource} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisResource} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    create(resourceGroupName: string, name: string, parameters: models.RedisCreateParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisResource>;
    create(resourceGroupName: string, name: string, parameters: models.RedisCreateParameters, callback: ServiceCallback<models.RedisResource>): void;
    create(resourceGroupName: string, name: string, parameters: models.RedisCreateParameters, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisResource>): void;

    /**
     * Update an existing Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters supplied to the Update Redis
     * operation.
     *
     * @param {object} [parameters.redisConfiguration] All Redis Settings. Few
     * possible keys:
     * rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
     * etc.
     *
     * @param {boolean} [parameters.enableNonSslPort] Specifies whether the non-ssl
     * Redis server port (6379) is enabled.
     *
     * @param {object} [parameters.tenantSettings] tenantSettings
     *
     * @param {number} [parameters.shardCount] The number of shards to be created
     * on a Premium Cluster Cache.
     *
     * @param {string} [parameters.subnetId] The full resource ID of a subnet in a
     * virtual network to deploy the Redis cache in. Example format:
     * /subscriptions/{subid}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
     *
     * @param {string} [parameters.staticIP] Static IP address. Required when
     * deploying a Redis cache inside an existing Azure Virtual Network.
     *
     * @param {object} [parameters.sku] The SKU of the Redis cache to deploy.
     *
     * @param {string} parameters.sku.name The type of Redis cache to deploy. Valid
     * values: (Basic, Standard, Premium). Possible values include: 'Basic',
     * 'Standard', 'Premium'
     *
     * @param {string} parameters.sku.family The SKU family to use. Valid values:
     * (C, P). (C = Basic/Standard, P = Premium). Possible values include: 'C', 'P'
     *
     * @param {number} parameters.sku.capacity The size of the Redis cache to
     * deploy. Valid values: for C (Basic/Standard) family (0, 1, 2, 3, 4, 5, 6),
     * for P (Premium) family (1, 2, 3, 4).
     *
     * @param {object} [parameters.tags] Resource tags.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisResource>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    updateWithHttpOperationResponse(resourceGroupName: string, name: string, parameters: models.RedisUpdateParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisResource>>;

    /**
     * Update an existing Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters supplied to the Update Redis
     * operation.
     *
     * @param {object} [parameters.redisConfiguration] All Redis Settings. Few
     * possible keys:
     * rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
     * etc.
     *
     * @param {boolean} [parameters.enableNonSslPort] Specifies whether the non-ssl
     * Redis server port (6379) is enabled.
     *
     * @param {object} [parameters.tenantSettings] tenantSettings
     *
     * @param {number} [parameters.shardCount] The number of shards to be created
     * on a Premium Cluster Cache.
     *
     * @param {string} [parameters.subnetId] The full resource ID of a subnet in a
     * virtual network to deploy the Redis cache in. Example format:
     * /subscriptions/{subid}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
     *
     * @param {string} [parameters.staticIP] Static IP address. Required when
     * deploying a Redis cache inside an existing Azure Virtual Network.
     *
     * @param {object} [parameters.sku] The SKU of the Redis cache to deploy.
     *
     * @param {string} parameters.sku.name The type of Redis cache to deploy. Valid
     * values: (Basic, Standard, Premium). Possible values include: 'Basic',
     * 'Standard', 'Premium'
     *
     * @param {string} parameters.sku.family The SKU family to use. Valid values:
     * (C, P). (C = Basic/Standard, P = Premium). Possible values include: 'C', 'P'
     *
     * @param {number} parameters.sku.capacity The size of the Redis cache to
     * deploy. Valid values: for C (Basic/Standard) family (0, 1, 2, 3, 4, 5, 6),
     * for P (Premium) family (1, 2, 3, 4).
     *
     * @param {object} [parameters.tags] Resource tags.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisResource} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisResource} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisResource} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    update(resourceGroupName: string, name: string, parameters: models.RedisUpdateParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisResource>;
    update(resourceGroupName: string, name: string, parameters: models.RedisUpdateParameters, callback: ServiceCallback<models.RedisResource>): void;
    update(resourceGroupName: string, name: string, parameters: models.RedisUpdateParameters, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisResource>): void;

    /**
     * Deletes a Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<null>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    deleteMethodWithHttpOperationResponse(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<void>>;

    /**
     * Deletes a Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {null} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {null} [result]   - The deserialized result object if an error did not occur.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    deleteMethod(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<void>;
    deleteMethod(resourceGroupName: string, name: string, callback: ServiceCallback<void>): void;
    deleteMethod(resourceGroupName: string, name: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<void>): void;

    /**
     * Gets a Redis cache (resource description).
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisResource>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    getWithHttpOperationResponse(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisResource>>;

    /**
     * Gets a Redis cache (resource description).
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisResource} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisResource} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisResource} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    get(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisResource>;
    get(resourceGroupName: string, name: string, callback: ServiceCallback<models.RedisResource>): void;
    get(resourceGroupName: string, name: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisResource>): void;

    /**
     * Lists all Redis caches in a resource group.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisListResult>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listByResourceGroupWithHttpOperationResponse(resourceGroupName: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisListResult>>;

    /**
     * Lists all Redis caches in a resource group.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisListResult} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisListResult} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisListResult} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    listByResourceGroup(resourceGroupName: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisListResult>;
    listByResourceGroup(resourceGroupName: string, callback: ServiceCallback<models.RedisListResult>): void;
    listByResourceGroup(resourceGroupName: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisListResult>): void;

    /**
     * Gets all Redis caches in the specified subscription.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisListResult>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listWithHttpOperationResponse(options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisListResult>>;

    /**
     * Gets all Redis caches in the specified subscription.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisListResult} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisListResult} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisListResult} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    list(options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisListResult>;
    list(callback: ServiceCallback<models.RedisListResult>): void;
    list(options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisListResult>): void;

    /**
     * Retrieve a Redis cache's access keys. This operation requires write
     * permission to the cache resource.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisAccessKeys>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listKeysWithHttpOperationResponse(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisAccessKeys>>;

    /**
     * Retrieve a Redis cache's access keys. This operation requires write
     * permission to the cache resource.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisAccessKeys} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisAccessKeys} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisAccessKeys} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    listKeys(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisAccessKeys>;
    listKeys(resourceGroupName: string, name: string, callback: ServiceCallback<models.RedisAccessKeys>): void;
    listKeys(resourceGroupName: string, name: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisAccessKeys>): void;

    /**
     * Regenerate Redis cache's access keys. This operation requires write
     * permission to the cache resource.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {string} keyType The Redis access key to regenerate. Possible values
     * include: 'Primary', 'Secondary'
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisAccessKeys>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    regenerateKeyWithHttpOperationResponse(resourceGroupName: string, name: string, keyType: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisAccessKeys>>;

    /**
     * Regenerate Redis cache's access keys. This operation requires write
     * permission to the cache resource.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {string} keyType The Redis access key to regenerate. Possible values
     * include: 'Primary', 'Secondary'
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisAccessKeys} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisAccessKeys} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisAccessKeys} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    regenerateKey(resourceGroupName: string, name: string, keyType: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisAccessKeys>;
    regenerateKey(resourceGroupName: string, name: string, keyType: string, callback: ServiceCallback<models.RedisAccessKeys>): void;
    regenerateKey(resourceGroupName: string, name: string, keyType: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisAccessKeys>): void;

    /**
     * Reboot specified Redis node(s). This operation requires write permission to
     * the cache resource. There can be potential data loss.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Specifies which Redis node(s) to reboot.
     *
     * @param {string} parameters.rebootType Which Redis node(s) to reboot.
     * Depending on this value data loss is possible. Possible values include:
     * 'PrimaryNode', 'SecondaryNode', 'AllNodes'
     *
     * @param {number} [parameters.shardId] If clustering is enabled, the ID of the
     * shard to be rebooted.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisForceRebootResponse>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    forceRebootWithHttpOperationResponse(resourceGroupName: string, name: string, parameters: models.RedisRebootParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisForceRebootResponse>>;

    /**
     * Reboot specified Redis node(s). This operation requires write permission to
     * the cache resource. There can be potential data loss.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Specifies which Redis node(s) to reboot.
     *
     * @param {string} parameters.rebootType Which Redis node(s) to reboot.
     * Depending on this value data loss is possible. Possible values include:
     * 'PrimaryNode', 'SecondaryNode', 'AllNodes'
     *
     * @param {number} [parameters.shardId] If clustering is enabled, the ID of the
     * shard to be rebooted.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisForceRebootResponse} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisForceRebootResponse} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisForceRebootResponse} for more
     *                      information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    forceReboot(resourceGroupName: string, name: string, parameters: models.RedisRebootParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisForceRebootResponse>;
    forceReboot(resourceGroupName: string, name: string, parameters: models.RedisRebootParameters, callback: ServiceCallback<models.RedisForceRebootResponse>): void;
    forceReboot(resourceGroupName: string, name: string, parameters: models.RedisRebootParameters, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisForceRebootResponse>): void;

    /**
     * Import data into Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters for Redis import operation.
     *
     * @param {string} [parameters.format] File format.
     *
     * @param {array} parameters.files files to import.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<null>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    importDataWithHttpOperationResponse(resourceGroupName: string, name: string, parameters: models.ImportRDBParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<void>>;

    /**
     * Import data into Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters for Redis import operation.
     *
     * @param {string} [parameters.format] File format.
     *
     * @param {array} parameters.files files to import.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {null} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {null} [result]   - The deserialized result object if an error did not occur.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    importData(resourceGroupName: string, name: string, parameters: models.ImportRDBParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<void>;
    importData(resourceGroupName: string, name: string, parameters: models.ImportRDBParameters, callback: ServiceCallback<void>): void;
    importData(resourceGroupName: string, name: string, parameters: models.ImportRDBParameters, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<void>): void;

    /**
     * Export data from the redis cache to blobs in a container.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters for Redis export operation.
     *
     * @param {string} [parameters.format] File format.
     *
     * @param {string} parameters.prefix Prefix to use for exported files.
     *
     * @param {string} parameters.container Container name to export to.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<null>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    exportDataWithHttpOperationResponse(resourceGroupName: string, name: string, parameters: models.ExportRDBParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<void>>;

    /**
     * Export data from the redis cache to blobs in a container.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters for Redis export operation.
     *
     * @param {string} [parameters.format] File format.
     *
     * @param {string} parameters.prefix Prefix to use for exported files.
     *
     * @param {string} parameters.container Container name to export to.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {null} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {null} [result]   - The deserialized result object if an error did not occur.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    exportData(resourceGroupName: string, name: string, parameters: models.ExportRDBParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<void>;
    exportData(resourceGroupName: string, name: string, parameters: models.ExportRDBParameters, callback: ServiceCallback<void>): void;
    exportData(resourceGroupName: string, name: string, parameters: models.ExportRDBParameters, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<void>): void;

    /**
     * Create or replace (overwrite/recreate, with potential downtime) an existing
     * Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters supplied to the Create Redis
     * operation.
     *
     * @param {object} [parameters.redisConfiguration] All Redis Settings. Few
     * possible keys:
     * rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
     * etc.
     *
     * @param {boolean} [parameters.enableNonSslPort] Specifies whether the non-ssl
     * Redis server port (6379) is enabled.
     *
     * @param {object} [parameters.tenantSettings] tenantSettings
     *
     * @param {number} [parameters.shardCount] The number of shards to be created
     * on a Premium Cluster Cache.
     *
     * @param {string} [parameters.subnetId] The full resource ID of a subnet in a
     * virtual network to deploy the Redis cache in. Example format:
     * /subscriptions/{subid}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
     *
     * @param {string} [parameters.staticIP] Static IP address. Required when
     * deploying a Redis cache inside an existing Azure Virtual Network.
     *
     * @param {object} parameters.sku The SKU of the Redis cache to deploy.
     *
     * @param {string} parameters.sku.name The type of Redis cache to deploy. Valid
     * values: (Basic, Standard, Premium). Possible values include: 'Basic',
     * 'Standard', 'Premium'
     *
     * @param {string} parameters.sku.family The SKU family to use. Valid values:
     * (C, P). (C = Basic/Standard, P = Premium). Possible values include: 'C', 'P'
     *
     * @param {number} parameters.sku.capacity The size of the Redis cache to
     * deploy. Valid values: for C (Basic/Standard) family (0, 1, 2, 3, 4, 5, 6),
     * for P (Premium) family (1, 2, 3, 4).
     *
     * @param {string} parameters.location Resource location.
     *
     * @param {object} [parameters.tags] Resource tags.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisResource>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    beginCreateWithHttpOperationResponse(resourceGroupName: string, name: string, parameters: models.RedisCreateParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisResource>>;

    /**
     * Create or replace (overwrite/recreate, with potential downtime) an existing
     * Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters supplied to the Create Redis
     * operation.
     *
     * @param {object} [parameters.redisConfiguration] All Redis Settings. Few
     * possible keys:
     * rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
     * etc.
     *
     * @param {boolean} [parameters.enableNonSslPort] Specifies whether the non-ssl
     * Redis server port (6379) is enabled.
     *
     * @param {object} [parameters.tenantSettings] tenantSettings
     *
     * @param {number} [parameters.shardCount] The number of shards to be created
     * on a Premium Cluster Cache.
     *
     * @param {string} [parameters.subnetId] The full resource ID of a subnet in a
     * virtual network to deploy the Redis cache in. Example format:
     * /subscriptions/{subid}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
     *
     * @param {string} [parameters.staticIP] Static IP address. Required when
     * deploying a Redis cache inside an existing Azure Virtual Network.
     *
     * @param {object} parameters.sku The SKU of the Redis cache to deploy.
     *
     * @param {string} parameters.sku.name The type of Redis cache to deploy. Valid
     * values: (Basic, Standard, Premium). Possible values include: 'Basic',
     * 'Standard', 'Premium'
     *
     * @param {string} parameters.sku.family The SKU family to use. Valid values:
     * (C, P). (C = Basic/Standard, P = Premium). Possible values include: 'C', 'P'
     *
     * @param {number} parameters.sku.capacity The size of the Redis cache to
     * deploy. Valid values: for C (Basic/Standard) family (0, 1, 2, 3, 4, 5, 6),
     * for P (Premium) family (1, 2, 3, 4).
     *
     * @param {string} parameters.location Resource location.
     *
     * @param {object} [parameters.tags] Resource tags.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisResource} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisResource} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisResource} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    beginCreate(resourceGroupName: string, name: string, parameters: models.RedisCreateParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisResource>;
    beginCreate(resourceGroupName: string, name: string, parameters: models.RedisCreateParameters, callback: ServiceCallback<models.RedisResource>): void;
    beginCreate(resourceGroupName: string, name: string, parameters: models.RedisCreateParameters, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisResource>): void;

    /**
     * Deletes a Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<null>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    beginDeleteMethodWithHttpOperationResponse(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<void>>;

    /**
     * Deletes a Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {null} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {null} [result]   - The deserialized result object if an error did not occur.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    beginDeleteMethod(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<void>;
    beginDeleteMethod(resourceGroupName: string, name: string, callback: ServiceCallback<void>): void;
    beginDeleteMethod(resourceGroupName: string, name: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<void>): void;

    /**
     * Import data into Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters for Redis import operation.
     *
     * @param {string} [parameters.format] File format.
     *
     * @param {array} parameters.files files to import.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<null>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    beginImportDataWithHttpOperationResponse(resourceGroupName: string, name: string, parameters: models.ImportRDBParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<void>>;

    /**
     * Import data into Redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters for Redis import operation.
     *
     * @param {string} [parameters.format] File format.
     *
     * @param {array} parameters.files files to import.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {null} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {null} [result]   - The deserialized result object if an error did not occur.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    beginImportData(resourceGroupName: string, name: string, parameters: models.ImportRDBParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<void>;
    beginImportData(resourceGroupName: string, name: string, parameters: models.ImportRDBParameters, callback: ServiceCallback<void>): void;
    beginImportData(resourceGroupName: string, name: string, parameters: models.ImportRDBParameters, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<void>): void;

    /**
     * Export data from the redis cache to blobs in a container.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters for Redis export operation.
     *
     * @param {string} [parameters.format] File format.
     *
     * @param {string} parameters.prefix Prefix to use for exported files.
     *
     * @param {string} parameters.container Container name to export to.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<null>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    beginExportDataWithHttpOperationResponse(resourceGroupName: string, name: string, parameters: models.ExportRDBParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<void>>;

    /**
     * Export data from the redis cache to blobs in a container.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {object} parameters Parameters for Redis export operation.
     *
     * @param {string} [parameters.format] File format.
     *
     * @param {string} parameters.prefix Prefix to use for exported files.
     *
     * @param {string} parameters.container Container name to export to.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {null} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {null} [result]   - The deserialized result object if an error did not occur.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    beginExportData(resourceGroupName: string, name: string, parameters: models.ExportRDBParameters, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<void>;
    beginExportData(resourceGroupName: string, name: string, parameters: models.ExportRDBParameters, callback: ServiceCallback<void>): void;
    beginExportData(resourceGroupName: string, name: string, parameters: models.ExportRDBParameters, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<void>): void;

    /**
     * Lists all Redis caches in a resource group.
     *
     * @param {string} nextPageLink The NextLink from the previous successful call
     * to List operation.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisListResult>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listByResourceGroupNextWithHttpOperationResponse(nextPageLink: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisListResult>>;

    /**
     * Lists all Redis caches in a resource group.
     *
     * @param {string} nextPageLink The NextLink from the previous successful call
     * to List operation.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisListResult} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisListResult} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisListResult} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    listByResourceGroupNext(nextPageLink: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisListResult>;
    listByResourceGroupNext(nextPageLink: string, callback: ServiceCallback<models.RedisListResult>): void;
    listByResourceGroupNext(nextPageLink: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisListResult>): void;

    /**
     * Gets all Redis caches in the specified subscription.
     *
     * @param {string} nextPageLink The NextLink from the previous successful call
     * to List operation.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisListResult>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listNextWithHttpOperationResponse(nextPageLink: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisListResult>>;

    /**
     * Gets all Redis caches in the specified subscription.
     *
     * @param {string} nextPageLink The NextLink from the previous successful call
     * to List operation.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisListResult} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisListResult} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisListResult} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    listNext(nextPageLink: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisListResult>;
    listNext(nextPageLink: string, callback: ServiceCallback<models.RedisListResult>): void;
    listNext(nextPageLink: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisListResult>): void;
}

/**
 * @class
 * FirewallRules
 * __NOTE__: An instance of this class is automatically created for an
 * instance of the RedisManagementClient.
 */
export interface FirewallRules {

    /**
     * Gets all firewall rules in the specified redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} cacheName The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisFirewallRuleListResult>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listWithHttpOperationResponse(resourceGroupName: string, cacheName: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisFirewallRuleListResult>>;

    /**
     * Gets all firewall rules in the specified redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} cacheName The name of the Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisFirewallRuleListResult} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisFirewallRuleListResult} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisFirewallRuleListResult} for more
     *                      information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    list(resourceGroupName: string, cacheName: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisFirewallRuleListResult>;
    list(resourceGroupName: string, cacheName: string, callback: ServiceCallback<models.RedisFirewallRuleListResult>): void;
    list(resourceGroupName: string, cacheName: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisFirewallRuleListResult>): void;

    /**
     * Gets all firewall rules in the specified redis cache.
     *
     * @param {string} nextPageLink The NextLink from the previous successful call
     * to List operation.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisFirewallRuleListResult>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    listNextWithHttpOperationResponse(nextPageLink: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisFirewallRuleListResult>>;

    /**
     * Gets all firewall rules in the specified redis cache.
     *
     * @param {string} nextPageLink The NextLink from the previous successful call
     * to List operation.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisFirewallRuleListResult} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisFirewallRuleListResult} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisFirewallRuleListResult} for more
     *                      information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    listNext(nextPageLink: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisFirewallRuleListResult>;
    listNext(nextPageLink: string, callback: ServiceCallback<models.RedisFirewallRuleListResult>): void;
    listNext(nextPageLink: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisFirewallRuleListResult>): void;
}

/**
 * @class
 * RedisFirewallRuleOperations
 * __NOTE__: An instance of this class is automatically created for an
 * instance of the RedisManagementClient.
 */
export interface RedisFirewallRuleOperations {

    /**
     * Create or update a redis cache firewall rule
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} cacheName The name of the Redis cache.
     *
     * @param {string} ruleName The name of the firewall rule.
     *
     * @param {object} parameters Parameters supplied to the create or update redis
     * firewall rule operation.
     *
     * @param {string} parameters.startIP lowest IP address included in the range
     *
     * @param {string} parameters.endIP highest IP address included in the range
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisFirewallRule>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    createOrUpdateWithHttpOperationResponse(resourceGroupName: string, cacheName: string, ruleName: string, parameters: models.RedisFirewallRule, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisFirewallRule>>;

    /**
     * Create or update a redis cache firewall rule
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} cacheName The name of the Redis cache.
     *
     * @param {string} ruleName The name of the firewall rule.
     *
     * @param {object} parameters Parameters supplied to the create or update redis
     * firewall rule operation.
     *
     * @param {string} parameters.startIP lowest IP address included in the range
     *
     * @param {string} parameters.endIP highest IP address included in the range
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisFirewallRule} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisFirewallRule} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisFirewallRule} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    createOrUpdate(resourceGroupName: string, cacheName: string, ruleName: string, parameters: models.RedisFirewallRule, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisFirewallRule>;
    createOrUpdate(resourceGroupName: string, cacheName: string, ruleName: string, parameters: models.RedisFirewallRule, callback: ServiceCallback<models.RedisFirewallRule>): void;
    createOrUpdate(resourceGroupName: string, cacheName: string, ruleName: string, parameters: models.RedisFirewallRule, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisFirewallRule>): void;

    /**
     * Gets a single firewall rule in a specified redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} cacheName The name of the Redis cache.
     *
     * @param {string} ruleName The name of the firewall rule.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisFirewallRule>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    getWithHttpOperationResponse(resourceGroupName: string, cacheName: string, ruleName: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisFirewallRule>>;

    /**
     * Gets a single firewall rule in a specified redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} cacheName The name of the Redis cache.
     *
     * @param {string} ruleName The name of the firewall rule.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisFirewallRule} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisFirewallRule} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisFirewallRule} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    get(resourceGroupName: string, cacheName: string, ruleName: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisFirewallRule>;
    get(resourceGroupName: string, cacheName: string, ruleName: string, callback: ServiceCallback<models.RedisFirewallRule>): void;
    get(resourceGroupName: string, cacheName: string, ruleName: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisFirewallRule>): void;

    /**
     * Deletes a single firewall rule in a specified redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} cacheName The name of the Redis cache.
     *
     * @param {string} ruleName The name of the firewall rule.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<null>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    deleteMethodWithHttpOperationResponse(resourceGroupName: string, cacheName: string, ruleName: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<void>>;

    /**
     * Deletes a single firewall rule in a specified redis cache.
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} cacheName The name of the Redis cache.
     *
     * @param {string} ruleName The name of the firewall rule.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {null} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {null} [result]   - The deserialized result object if an error did not occur.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    deleteMethod(resourceGroupName: string, cacheName: string, ruleName: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<void>;
    deleteMethod(resourceGroupName: string, cacheName: string, ruleName: string, callback: ServiceCallback<void>): void;
    deleteMethod(resourceGroupName: string, cacheName: string, ruleName: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<void>): void;
}

/**
 * @class
 * PatchSchedules
 * __NOTE__: An instance of this class is automatically created for an
 * instance of the RedisManagementClient.
 */
export interface PatchSchedules {

    /**
     * Create or replace the patching schedule for Redis cache (requires Premium
     * SKU).
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {array} scheduleEntries List of patch schedules for a Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisPatchSchedule>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    createOrUpdateWithHttpOperationResponse(resourceGroupName: string, name: string, scheduleEntries: models.ScheduleEntry[], options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisPatchSchedule>>;

    /**
     * Create or replace the patching schedule for Redis cache (requires Premium
     * SKU).
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the Redis cache.
     *
     * @param {array} scheduleEntries List of patch schedules for a Redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisPatchSchedule} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisPatchSchedule} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisPatchSchedule} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    createOrUpdate(resourceGroupName: string, name: string, scheduleEntries: models.ScheduleEntry[], options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisPatchSchedule>;
    createOrUpdate(resourceGroupName: string, name: string, scheduleEntries: models.ScheduleEntry[], callback: ServiceCallback<models.RedisPatchSchedule>): void;
    createOrUpdate(resourceGroupName: string, name: string, scheduleEntries: models.ScheduleEntry[], options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisPatchSchedule>): void;

    /**
     * Deletes the patching schedule of a redis cache (requires Premium SKU).
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<null>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    deleteMethodWithHttpOperationResponse(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<void>>;

    /**
     * Deletes the patching schedule of a redis cache (requires Premium SKU).
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {null} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {null} [result]   - The deserialized result object if an error did not occur.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    deleteMethod(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<void>;
    deleteMethod(resourceGroupName: string, name: string, callback: ServiceCallback<void>): void;
    deleteMethod(resourceGroupName: string, name: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<void>): void;

    /**
     * Gets the patching schedule of a redis cache (requires Premium SKU).
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @returns {Promise} A promise is returned
     *
     * @resolve {HttpOperationResponse<RedisPatchSchedule>} - The deserialized result object.
     *
     * @reject {Error|ServiceError} - The error object.
     */
    getWithHttpOperationResponse(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<HttpOperationResponse<models.RedisPatchSchedule>>;

    /**
     * Gets the patching schedule of a redis cache (requires Premium SKU).
     *
     * @param {string} resourceGroupName The name of the resource group.
     *
     * @param {string} name The name of the redis cache.
     *
     * @param {object} [options] Optional Parameters.
     *
     * @param {object} [options.customHeaders] Headers that will be added to the
     * request
     *
     * @param {ServiceCallback} [optionalCallback] - The optional callback.
     *
     * @returns {ServiceCallback|Promise} If a callback was passed as the last
     * parameter then it returns the callback else returns a Promise.
     *
     * {Promise} A promise is returned.
     *
     *                      @resolve {RedisPatchSchedule} - The deserialized result object.
     *
     *                      @reject {Error|ServiceError} - The error object.
     *
     * {ServiceCallback} optionalCallback(err, result, request, response)
     *
     *                      {Error|ServiceError}  err        - The Error object if an error occurred, null otherwise.
     *
     *                      {RedisPatchSchedule} [result]   - The deserialized result object if an error did not occur.
     *                      See {@link RedisPatchSchedule} for more information.
     *
     *                      {WebResource} [request]  - The HTTP Request object if an error did not occur.
     *
     *                      {http.IncomingMessage} [response] - The HTTP Response stream if an error did not occur.
     */
    get(resourceGroupName: string, name: string, options?: { customHeaders? : { [headerName: string]: string; } }): Promise<models.RedisPatchSchedule>;
    get(resourceGroupName: string, name: string, callback: ServiceCallback<models.RedisPatchSchedule>): void;
    get(resourceGroupName: string, name: string, options: { customHeaders? : { [headerName: string]: string; } }, callback: ServiceCallback<models.RedisPatchSchedule>): void;
}


text:
@interface MFHostGameController : MFMultiplayerGameController {

	IBOutlet NSButton *startGameButton;

	NSNetService *service;
	NSFileHandle *listeningSocket;
	NSMutableDictionary *playerDict;

	IBOutlet NSButton *kickPlayerButton;
	NSNib  *hostGameSheetNib;

	// Game Tracker
	NSTimer *trackerTimer;
}

- (id)initWithObjectDict:(NSDictionary *)objectDict;
- (void)dealloc;

- (void)addPlayer:(id)newPlayer;
- (void)removePlayer:(id)aPlayer wasKicked:(BOOL)wasKicked;
- (IBAction)kickPlayer:(id)sender;
- (NSData *)playersData;

@end
@interface MFHostGameController (LobbySheet)
- (void)openLobbySheet;

- (void)newPlayerConnected:(NSNotification *)notification;

- (IBAction)returnChatMessage:(id)sender;
- (void)broadcastChatMessage:(NSString *)messageString from:(id)player;
- (IBAction)gridSizeChanged:(id)sender;
- (IBAction)hotCornerSwitch:(id)sender;
- (IBAction)gameSpeedChanged:(id)sender;

- (IBAction)startHostGame:(id)sender;
- (IBAction)cancelHostGame:(id)sender;
- (void)backToLobby;
@end

@interface MFHostGameController (GameGridControl)
- (void)sendDataToPlayers:(NSData *)data withException:(id)exception;
- (void)currentPlayerPlacedShapeAtRow:(int)row column:(int)col sender:(id)sender;
- (void)currentPlayerPressedBiteButton:(id)sender;
- (void)currentPlayerRotatedShape:(id)sender;
- (void)currentPlayerPlacedBiteAtRow:(int)row column:(int)col sender:(id)sender;
- (void)currentPlayerPlacedBigBiteAtRow:(int)row column:(int)col sender:(id)sender;
- (void)currentPlayerSkippedTurn:(id)sender;

- (int)nextShape;

- (void)noMorePlayersSheetDidEnd:(NSAlert *)alert returnCode:(int)returnCode contextInfo:(void *)contextInfo;
- (void)disconnectedPlayersSheetDidEnd:(NSAlert *)alert returnCode:(int)returnCode contextInfo:(void *)contextInfo;
@end

@interface MFHostGameController (NSNetServiceDelegation)
// Publication Specific
- (void)setupService;
- (void)updateService;
- (void)stopService;
- (void)netService:(NSNetService *)sender didNotPublish:(NSDictionary *)errorDict;
- (void)netServiceWillPublish:(NSNetService *)sender;
- (void)netServiceDidStop:(NSNetService *)sender;

// Resolution Specific
- (void)netService:(NSNetService *)sender didNotResolve:(NSDictionary *)errorDict;
- (void)netServiceDidResolveAddress:(NSNetService *)sender;
- (void)netServiceWillResolve:(NSNetService *)sender;

@end

@interface MFHostGameController (ColorChange)
- (BOOL)colorChanged:(id)sender;
@end

@interface MFHostGameController (GameTracker)
- (void)startTrackerTimer;
- (void)stopTrackerTimer;
- (void)updateTracker;
@end

@interface NSString (ReplaceAndEncode)
- (NSString *)replaceMatchingCharacters:(char)character withString:(NSString*)replacement;
- (NSString*)encryptStringWithPassword:(NSString*)password;
@end

redpajama_set_name: RedPajamaGithub


text:
#ifndef itkCorrespondenceDataStructureIterator_h
#define itkCorrespondenceDataStructureIterator_h

#include "itkMacro.h"

namespace itk
{
/** \class CorrespondenceDataStructureIterator
 * \brief An iterator designed to easily traverse an
 *        CorrespondenceDataStructure.
 *
 * \ingroup ITKCommon
 */
template< typename TStructureType >
class ITK_TEMPLATE_EXPORT CorrespondenceDataStructureIterator
{
public:
  /** Standard class typedefs. */
  typedef CorrespondenceDataStructureIterator Self;

  /** Get the dimension (size) of the index. */
  static unsigned int GetIteratorDimension()
  {
    return TStructureType::dim;
  }

  /** Is the iterator at the end of the region? */
  bool IsAtEnd();

  /** Walk forward one index. (prefix) */
  void operator++(){ GoToNext(); }

  /** Walk forward one index. (postfix) */
  void operator++(int){ GoToNext(); }

  /** Goes to the next corresponding node clique in the structure,
   *  moving on to the next base node clique if necessary. */
  void GoToNext();

  /** Goes to the next base node clique. */
  void GoToNextBaseGroup();

  /** Resets the iterator. */
  void Reset();

  /** Constructor */
  CorrespondenceDataStructureIterator(TStructureType *StructurePtr);

  /** Destructor */
  virtual ~CorrespondenceDataStructureIterator();

  typedef typename TStructureType::CorrespondingListType CorrespondingListType;
  typedef typename TStructureType::ItemType              ItemType;
  typedef typename TStructureType::SecondaryNodeListType SecondaryNodeListType;
  typedef typename TStructureType::NodeListType          NodeListType;

  typedef typename CorrespondingListType::iterator CorrespondingListIterator;
  typedef typename SecondaryNodeListType::iterator SecondaryNodeListIterator;
  typedef typename NodeListType::iterator          NodeListIterator;

  /** Get m_CorrespondingListPointer.  */
  CorrespondingListType * GetCorrespondingListPointer()
  {
    return m_CorrespondingListPointer;
  }

  CorrespondingListIterator m_CorrespondingListIterator;
  SecondaryNodeListIterator m_SecondaryListIterator;

  typename TStructureType::NodeListType::iterator m_NodeListIterator;

protected:

  /** Is the iterator at the end of its walk? */
  bool                   m_IsAtEnd;
  TStructureType *       m_Structure;
  ItemType *             m_CorrespondingNodePointer;
  CorrespondingListType *m_CorrespondingListPointer;
  SecondaryNodeListType *m_SecondaryListPointer;
  NodeListType *         m_NodeListPointer;
};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkCorrespondenceDataStructureIterator.hxx"
#endif

#endif


text:
<?php
namespace Chamilo\Core\Repository\ContentObject\SystemAnnouncement\Filter\Renderer;

use Chamilo\Core\Repository\ContentObject\SystemAnnouncement\Filter\FilterData;
use Chamilo\Core\Repository\ContentObject\SystemAnnouncement\Storage\DataClass\SystemAnnouncement;
use Chamilo\Libraries\Translation\Translation;

/**
 * Render the parameters set via FilterData as a FormValidator
 *
 * @author Hans De Bisschop <hans.de.bisschop@ehb.be>
 */
class FormFilterRenderer extends \Chamilo\Core\Repository\Filter\Renderer\FormFilterRenderer
{

    /**
     *
     * @see \core\repository\filter\renderer\FormFilterRenderer::build()
     */
    public function build()
    {
        parent::build();

        $form_validator = $this->get_form_validitor();
        $renderer = $this->get_renderer();

        $form_validator->addElement('category', Translation::get('Icon'));
        $options = SystemAnnouncement::get_possible_icons();
        asort($options);
        $options = array(0 => '-- ' . Translation::get('SelectIcon') . ' --') + $options;
        $form_validator->addElement('select', FilterData::FILTER_ICON, Translation::get('Icon'), $options);

        $form_validator->addElement('category');
    }

    /**
     *
     * @see \core\repository\filter\renderer\FormFilterRenderer::set_defaults()
     */
    public function set_defaults($defaults = array())
    {
        $filter_data = $this->get_filter_data();

        $defaults[FilterData::FILTER_ICON] = $filter_data->get_filter_property(FilterData::FILTER_ICON);
        parent::set_defaults($defaults);
    }
}