// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/diagnostics/logger.d.ts
declare module '~azure-storage/lib/common/diagnostics/logger' {
﻿// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* @class
* The Logger class is used to write log information.
*/
class Logger {
    /**
   * The log level. Refer to the Logger.LogLevels for available log levels. 
   * @name  Logger#level
   * @type  {string}
   * @see Logger.LogLevels
   */
    level: string;
    
    /**
    * @constructor
    * Creates a new Logger object
    * @param {string} [level]           The log level. Refer to Logger.LogLevels.
    * @param {object} [loggerFunction]  The function to write log information.
    */
    constructor(level?: string, loggerFunction?: (level: string, msg: string) => void);
    
    log(level: string, msg: string): void;
    emergency(msg: string): void;
    critical(msg: string): void;
    alert(msg: string): void;
    error(msg: string): void;
    warn(msg: string): void;
    notice(msg: string): void;
    info(msg: string): void;
    debug(msg: string): void;
     
    /**
    * The available log levels.
    *
    * @const
    * @enum {string}
    */
    static LogLevels: {
        /**
        * System is unusable.
        */
        EMERGENCY: 'emergency',

        /**
        * Action must be taken immediately.
        */
        ALERT : 'alert',

        /**
        * Critical condition.
        */
        CRITICAL : 'critical',

        /**
        * Error condition.
        */
        ERROR : 'error',

        /**
        * Warning condition.
        */
        WARNING : 'warning',

        /**
        * Normal but significant condition.
        */
        NOTICE : 'notice',

        /**
        * Purely informational message.
        */
        INFO : 'info',

        /**
        * Application debug messages.
        */
        DEBUG : 'debug'
    };
}

export = Logger;
}
declare module 'azure-storage/lib/common/diagnostics/logger' {
import main = require('~azure-storage/lib/common/diagnostics/logger');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/http/webresource.d.ts
declare module '~azure-storage/lib/common/http/webresource' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

type Map<T> = { [key: string]: T };

/**
* This class provides an abstraction over a REST call by being library / implementation agnostic and wrapping the necessary
* properties to initiate a request.
*/
class WebResource {
    rawResponse: boolean;
    headersOnly: boolean;
    queryString: Map<any>;
    properties: Map<string>;
    headers: Map<any>;
    body: any;
    /**
    * @constructor
    * Creates a new WebResource object.
    */
    constructor();
    
    /**
    * Creates a new put request web resource.
    *
    * @param {string} [path] The path for the put operation.
    * @return {WebResource} A new webresource with a put operation for the given path.
    */
    static put(path?: string): WebResource;
    
    /**
    * Creates a new get request web resource.
    *
    * @param {string} [path] The path for the get operation.
    * @return {WebResource} A new webresource with a get operation for the given path.
    */
    static get(path?: string): WebResource;
    
    /**
    * Creates a new head request web resource.
    *
    * @param {string} [path] The path for the head operation.
    * @return {WebResource} A new webresource with a head operation for the given path.
    */
    static head(path?: string): WebResource;
    
    /**
    * Creates a new del request web resource.
    *
    * @param {string} [path] The path for the del operation.
    * @return {WebResource} A new webresource with a del operation for the given path.
    */
    static del(path?: string): WebResource;
    
    /**
    * Creates a new post request web resource.
    *
    * @param {string} [path] The path for the post operation.
    * @return {WebResource} A new webresource with a post operation for the given path.
    */
    static post(path?: string): WebResource;
    
    /**
    * Creates a new merge request web resource.
    *
    * @param {string} [path] The path for the merge operation.
    * @return {WebResource} A new webresource with a merge operation for the given path.
    */
    static merge(path?: string): WebResource;
    
    /**
    * Specifies a custom property in the web resource.
    *
    * @param {string} name  The property name.
    * @param {string} value The property value.
    * @return {WebResource} The webresource.
    */
    withProperty(name: string, value: string): this;
    
    /**
    * Specifies that the response should not be parsed.
    * @return {WebResource} The webresource.
    */
    withRawResponse(): this;
    /**
    * Specifies if the response should be parsed or not.
    *
    * @param {bool} rawResponse true if the response should not be parsed; false otherwise.
    * @return {WebResource} The webresource.
    */
    withRawResponse(rawResponse?: boolean): this;
        
    /**
    * Specifies that the response should contains only headers.
    * @return {WebResource} The webresource.
    */
    withHeadersOnly(): this;
    /**
    * Specifies if the response should be contains only headers or not.
    *
    * @param {bool} headersOnly true if the response should contains only headers; false otherwise.
    * @return {WebResource} The webresource.
    */
    withHeadersOnly(headersOnly?: boolean): this;
    
    /**
    * Adds an optional query string parameter.
    *
    * @param {Object} name          The name of the query string parameter.
    * @param {Object} value         The value of the query string parameter.
    * @param {Object} [defaultValue]The default value for the query string parameter to be used if no value is passed.
    * @return {WebResource} The web resource.
    */
    withQueryOption(name: string, value: any, defaultValue?: any): this;
    
    /**
    * Adds optional query string parameters.
    * Additional arguments will be the needles to search in the haystack. 
    *
    * @param {Object} object  The haystack of query string parameters.
    * @return {WebResource} The web resource.
    */
    withQueryOptions(options: Map<any>, ...properties: string[]): this;
    
    /**
    * Adds an optional header parameter.
    *
    * @param {Object} name  The name of the header parameter.
    * @param {Object} value The value of the header parameter.
    * @return {WebResource} The web resource.
    */
    withHeader(name: string, value: any): this;
    
    /**
    * Adds optional header parameters.
    *
    * Additional arguments will be the needles to search in the haystack. 
    *
    * @param {Object} object  The haystack of headers.
    * @return {Object} The web resource.
    */
    withHeaders(options: Map<any>, ...properties: string[]): this;

    /**
    * Adds an optional body.
    *
    * @param {Object} body  The request body.
    * @return {WebResource} The web resource.
    */
    withBody(body: any): this;
    
    addOptionalMetadataHeaders(metadata: Map<any>): this;
    
    static validResponse(statusCode: number): boolean;
    
    /**
    * Hook up the given input stream to a destination output stream if the WebResource method
    * requires a request body and a body is not already set.
    *
    * @param {Stream} inputStream the stream to pipe from
    * @param {Stream} outputStream the stream to pipe to
    *
    * @return destStream
    */
    pipeInput(inputStream: NodeJS.ReadableStream, outputStream: NodeJS.WritableStream): typeof outputStream;   
}

export = WebResource;
}
declare module 'azure-storage/lib/common/http/webresource' {
import main = require('~azure-storage/lib/common/http/webresource');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/services/storageserviceclient.d.ts
declare module '~azure-storage/lib/common/services/storageserviceclient' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

import * as events from 'events';
import Logger = require('~azure-storage/lib/common/diagnostics/logger');
import WebResource = require('~azure-storage/lib/common/http/webresource');
import RetryPolicyFilter = require('~azure-storage/lib/common/filters/retrypolicyfilter');
import { date } from '~azure-storage/lib/common/util/date';
import { AccessConditions } from '~azure-storage/lib/common/util/accesscondition';
import { StorageError } from '~azure-storage/lib/common/errors/errors';

/**
* @class
* The StorageServiceClient class is the base class of all the service classes.
*/
class StorageServiceClient extends events.EventEmitter {
    storageAccount: string;
    storageAccessKey: string;
    sasToken: string;
    anonymous: boolean;
    storageCredentials: StorageServiceClient.IRequestSigner;
    
    apiVersion: string;
    usePathStyleUri: boolean;
    xml2jsSettings: any;
    defaultLocationMode: number;
    
    logger: Logger;
    host: StorageServiceClient.Host;
    
    /**
    * @constructor
    * Creates a new StorageServiceClient object.
    *
    * @param {string} [storageAccount]           The storage account.
    * @param {string} [storageAccessKey]         The storage access key.
    * @param {object} [host]                     The host for the service.
    * @param {bool}   [usePathStyleUri]          Boolean value indicating wether to use path style uris.
    * @param {string} [sasToken]                 The Shared Access Signature token.
    */
    constructor(storageAccount?: string, storageAccessKey?: string, host?: StorageServiceClient.Host, usePathStyleUri?: boolean, sasToken?: string);
    
    /**
    * Associate a filtering operation with this StorageServiceClient. Filtering operations
    * can include logging, automatically retrying, etc. Filter operations are objects
    * that implement a method with the signature:
    *
    *     "function handle (requestOptions, next)".
    *
    * After doing its preprocessing on the request options, the method needs to call
    * "next" passing a callback with the following signature:
    * signature:
    *
    *     "function (returnObject, finalCallback, next)"
    *
    * In this callback, and after processing the returnObject (the response from the
    * request to the server), the callback needs to either invoke next if it exists to
    * continue processing other filters or simply invoke finalCallback otherwise to end
    * up the service invocation.
    *
    * @param {Object} filter The new filter object.
    * @return {StorageServiceClient} A new service client with the filter applied.
    */
    withFilter(newFilter: RetryPolicyFilter.IRetryFilter): this;
    
    /**
    * Sets a host for the service.
    * @param {object}     host                              The host for the service.
    */
    setHost(host: StorageServiceClient.Host): void;
    
    /**
    * Gets the storage settings.
    *
    * @param {string} [storageAccountOrConnectionString]  The storage account or the connection string.
    * @param {string} [storageAccessKey]                  The storage access key.
    * @param {string} [host]                              The host address.
    * @param {object} [sasToken]                          The sas token.
    *
    * @return {StorageServiceSettings}
    */
    getStorageSettings(storageAccountOrConnectionString?: string, storageAccessKey?: string, host?: StorageServiceClient.HostConfiguration, sasToken?: string): StorageServiceClient.StorageServiceSettings;
    
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getAccountServiceProperties(callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {object}       options                                 The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getAccountServiceProperties(options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @this {StorageServiceClient}
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {ServiceOptions}     options                                  The request options.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setAccountServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @this {StorageServiceClient}
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setAccountServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResponse): void;
}

namespace StorageServiceClient {
    export type HostConfiguration = string | Host;
    export type ErrorOrResponse = (err: StorageError, response: ServiceResponse) => void;
    export type ErrorOrResult<T> = (err: StorageError, result: T, response: ServiceResponse) => void;
    export type ErrorOrList<T> = (err: StorageError, result: List<T>, response: ServiceResponse) => void;
    
    export interface List<T> {
        entries: T[];
        continuationToken: ContinuationToken;
    }
     
    export interface Host {
        primaryHost?: string;
        secondaryHost?: string;
    }

    export interface IRequestSigner {
        signRequest(webResource: WebResource, callback: (err: Error) => void): void;
    }
    
    export interface StorageServiceSettings {
        _name: string;
        _key: string;
        _sasToken: string;
        _blobEndpoint: string;
        _queueEndpoint: string;
        _tableEndpoint: string;
        _fileEndpoint: string;
        _usePathStyleUri: boolean;
    }
    
    export interface ServiceProperties {
        Logging?: ServiceLogging;
        HourMetrics?: ServiceMetrics;
        MinuteMetrics?: ServiceMetrics;
        Cors?: ServiceCorsRule[];
        
        /** The DefaultServiceVersion element can only be set for the Blob service and the request must be made using version 2011-08-18 or later. */
        DefaultServiceVersion?: string;
    }
    
    export interface ServiceLogging {
        Version: string;
        Delete: boolean;
        Read: boolean;
        Write: boolean;
        RetentionPolicy: ServiceRetentionPolicy;
    }
    
    export interface ServiceMetrics {
        Version: string;
        Enabled: boolean;
        IncludeAPIs?: boolean;
        RetentionPolicy: ServiceRetentionPolicy;
    }
    
    export interface ServiceRetentionPolicy {
        Enabled: boolean;
        Days?: number;
    }
    
    export interface ServiceCorsRule {
        CorsRule: {
            AllowedOrigins: string[];
            AllowedMethods: string[];
            AllowedHeaders: string[];
            ExposedHeaders: string[];
            MaxAgeInSeconds: number;
        };
    }
    
    export interface ServiceStats {
        GeoReplication?: {
            Status?: string;
            LastSyncTime?: Date;
        };
    }
    
    export interface ServiceOptions {
        /**
         * Specifies the location mode used to decide which location the request should be sent to. 
         * Please see StorageUtilities.LocationMode for the possible values.
         */
        locationMode?: number;
        
        /** The server timeout interval, in milliseconds, to use for the request. */
        timeoutIntervalInMs?: number;
        
        /**
         * The maximum execution time, in milliseconds, across all potential retries, to use when making this request.
         * The maximum execution time interval begins at the time that the client begins building the request. The maximum
         * execution time is checked intermittently while performing requests, and before executing retries.
         */
        maximumExecutionTimeInMs?: number;
        
        /**
         * Determines whether the Nagle algorithm is used; true to use the Nagle algorithm; otherwise, false.
         * The default value is false.
         */
        useNagleAlgorithm?: boolean;
    }
    
    export interface AccessConditionsOptions extends ServiceClientOptions {
        accessConditions?: AccessConditions;
    }
    
    export interface ServiceClientOptions extends ServiceOptions {
        /** A string that represents the client request ID with a 1KB character limit. */
        clientRequestId?: string;
    }
    
    export interface ServiceResponse {
        /** Boolean value indicating if the request was successful. */
        isSuccessful: boolean;
        /** The response body. */
        body: any;
        /** The response headers. */
        headers: any;
        /** The response status code. */
        statusCode: number;
        /** The response's content md5 hash. */
        md5: string;
    }
    
    export interface SignedIdentifiers {
        [key: string]: AccessPolicy;
    }
    
    export interface SharedAccessPolicy {
        /** The signed identifier. */
        Id?: string;
        /** The Access Policy information. */
        AccessPolicy?: AccessPolicy;
    }
    
    export interface AccessPolicy {
        /** The permission type. */
        Permissions?: string;
        /** The time at which the Shared Access Signature becomes valid (The UTC value will be used). */
        Start?: date;
        /** The time at which the Shared Access Signature becomes expired (The UTC value will be used). */
        Expiry?: date;
        /** An IP address or a range of IP addresses from which to accept requests. When specifying a range, note that the range is inclusive. */
        IPAddressOrRange?: string;
        /** 
         * The protocol permitted for a request made with the account SAS.
         * Possible values are both HTTPS and HTTP (https,http) or HTTPS only (https). 
         * The default value is https,http.
         */
        Protocols?: string;
    }
    
    export interface SignedIdentifiersResult {
        [key: string]: AccessPolicyResult;
    }
    
    export interface AccessPolicyResult {
        /** The permission type. */
        Permissions?: string;
        /** The time at which the Shared Access Signature becomes valid (The UTC value will be used). */
        Start?: Date;
        /** The time at which the Shared Access Signature becomes expired (The UTC value will be used). */
        Expiry?: Date;
        /** An IP address or a range of IP addresses from which to accept requests. When specifying a range, note that the range is inclusive. */
        IPAddressOrRange?: string;
        /** 
         * The protocol permitted for a request made with the account SAS.
         * Possible values are both HTTPS and HTTP (https,http) or HTTPS only (https). 
         * The default value is https,http.
         */
        Protocols?: string;
    }
    
    export interface ContinuationToken {
        
    }
}

export = StorageServiceClient;
}
declare module 'azure-storage/lib/common/services/storageserviceclient' {
import main = require('~azure-storage/lib/common/services/storageserviceclient');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/filters/linearretrypolicyfilter.d.ts
declare module '~azure-storage/lib/common/filters/linearretrypolicyfilter' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

import * as RetryPolicyFilter from '~azure-storage/lib/common/filters/retrypolicyfilter';

/**
* @class
* The LinearRetryPolicyFilter allows you to retry operations,
* using an linear back-off interval between retries.
* To apply a filter to service operations, use `withFilter`
* and specify the filter to be used when creating a service.
*/
class LinearRetryPolicyFilter implements RetryPolicyFilter.IRetryFilter {
    retryCount: number;
    retryInterval: number;

    /**
    * @constructor
    * @param {number} [retryCount=3]            The client retry count.
    * @param {number} [retryInterval=30000]     The client retry interval, in milliseconds.
    */
    constructor(retryCount?: number, retryInterval?: number);

    /**
    * Represents the default client retry interval, in milliseconds.
    */
    static DEFAULT_CLIENT_RETRY_INTERVAL: number;

    /**
    * Represents the default client retry count.
    */
    static DEFAULT_CLIENT_RETRY_COUNT: number;
    
    handle(requestOptions: any, next: RetryPolicyFilter.HandleCallback): void;
    shouldRetry(statusCode: number, requestOptions: any): RetryPolicyFilter.RetryInfo;
}

export = LinearRetryPolicyFilter;
}
declare module 'azure-storage/lib/common/filters/linearretrypolicyfilter' {
import main = require('~azure-storage/lib/common/filters/linearretrypolicyfilter');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/filters/exponentialretrypolicyfilter.d.ts
declare module '~azure-storage/lib/common/filters/exponentialretrypolicyfilter' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

import * as RetryPolicyFilter from '~azure-storage/lib/common/filters/retrypolicyfilter';

/**
* @class
* The ExponentialRetryPolicyFilter allows you to retry operations,
* using an exponential back-off interval between retries.
* To apply a filter to service operations, use `withFilter`
* and specify the filter to be used when creating a service.
*/
class ExponentialRetryPolicyFilter implements RetryPolicyFilter.IRetryFilter {
    retryCount: number;
    retryInterval: number;
    minRetryInterval: number;
    maxRetryInterval: number;
    
    /**
    * @constructor
    * @param {number} [retryCount=3]            The client retry count.
    * @param {number} [retryInterval=30000]     The client retry interval, in milliseconds.
    * @param {number} [minRetryInterval=3000]   The minimum retry interval, in milliseconds.
    * @param {number} [maxRetryInterval=90000]  The maximum retry interval, in milliseconds.
    */
    constructor(retryCount?: number, retryInterval?: number, minRetryInterval?: number, maxRetryInterval?: number);

    /**
    * Represents the default client retry interval, in milliseconds.
    */
    static DEFAULT_CLIENT_RETRY_INTERVAL: number;

    /**
    * Represents the default client retry count.
    */
    static DEFAULT_CLIENT_RETRY_COUNT: number;
    
    /**
    * Represents the default maximum retry interval, in milliseconds.
    */
    static DEFAULT_CLIENT_MAX_RETRY_INTERVAL: number;

    /**
    * Represents the default minimum retry interval, in milliseconds.
    */
    static DEFAULT_CLIENT_MIN_RETRY_INTERVAL: number;
    
    handle(requestOptions: any, next: RetryPolicyFilter.HandleCallback): void;
    shouldRetry(statusCode: number, requestOptions: any): RetryPolicyFilter.RetryInfo;
}

export = ExponentialRetryPolicyFilter;
}
declare module 'azure-storage/lib/common/filters/exponentialretrypolicyfilter' {
import main = require('~azure-storage/lib/common/filters/exponentialretrypolicyfilter');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/filters/retrypolicyfilter.d.ts
declare module '~azure-storage/lib/common/filters/retrypolicyfilter' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* @class
* The RetryPolicyFilter allows you to retry operations,
* using a custom retry policy. Users are responsible to 
* define the shouldRetry method.
* To apply a filter to service operations, use `withFilter`
* and specify the filter to be used when creating a service.
*/
class RetryPolicyFilter implements RetryPolicyFilter.IRetryFilter {
    retryCount: number;
    retryInterval: number;

    /**
    * @constructor
    * @param {number} [retryCount=30000]    The client retry count.
    * @param {number} [retryInterval=3]     The client retry interval, in milliseconds.
    */
    constructor(retryCount?: number, retryInterval?: number);

    /**
    * Represents the default client retry interval, in milliseconds.
    */
    static DEFAULT_CLIENT_RETRY_INTERVAL: number;

    /**
    * Represents the default client retry count.
    */
    static DEFAULT_CLIENT_RETRY_COUNT: number;

    /**
    * Handles an operation with a retry policy.
    *
    * @param {Object}   requestOptions The original request options.
    * @param {function} next           The next filter to be handled.
    */
    handle(requestOptions: any, next: RetryPolicyFilter.HandleCallback): void;

    /**
    * Implements a should-retry policy. TO BE IMPLEMENTED!
    * @abstract
    * @param {number} statusCode       The request status code.
    * @param {Object}   requestOptions The original request options.
    */
    /*abstract*/ shouldRetry(statusCode: number, requestOptions: any): RetryPolicyFilter.RetryInfo;

    /**
    * Handles an operation with a retry policy.
    *
    * @param {Object}   requestOptions The original request options.
    * @param {function} next           The next filter to be handled.
    */
    static _handle(self: RetryPolicyFilter, requestOptions: any, next: RetryPolicyFilter.HandleCallback): void;

    static __shouldRetryOnError(statusCode: number, requestOptions: any): RetryPolicyFilter.RetryInfo;
}

namespace RetryPolicyFilter {
    export interface IRetryFilter {
        retryCount?: number;
        retryInterval?: number;

        handle(requestOptions: any, next: HandleCallback): void;
        shouldRetry(statusCode: number, requestOptions: any): RetryInfo;
    }
    
    export interface ReturnObject {
        error?: Error;
        retryable?: boolean;
        response?: any;
    }

    export interface RetryInfo {
        retryCount?: number;
        retryInterval?: number;
        locationMode?: string;
        currentLocation?: string;
        error?: Error;
        lastServerError?: boolean;
        ignore?: boolean;
        retryable?: boolean;
    }
    
    export interface NextCallback {
        (returnObject: ReturnObject): void;
    }

    export interface HandleCallback {
        (returnObject: ReturnObject, finalCallback: NextCallback, next: NextCallback): void;
    }
}

export = RetryPolicyFilter;
}
declare module 'azure-storage/lib/common/filters/retrypolicyfilter' {
import main = require('~azure-storage/lib/common/filters/retrypolicyfilter');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/streams/speedsummary.d.ts
declare module '~azure-storage/lib/common/streams/speedsummary' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* Blob upload/download speed summary
*/
class SpeedSummary {
    name: string;
    _startTime: Date;
    _timeWindowInSeconds: number;
    _timeWindow: number;
    _totalWindowSize: number;
    _speedTracks: any[];
    _speedTrackPtr: number;
    totalSize: number;
    completeSize: number;
    
    constructor(name?: string);
    
    /** Get running seconds. */
    getElapsedSeconds(): number;
    /** Get running seconds. */
    getElapsedSeconds(humanReadable: boolean): number | string;
    
    /**
    * Get complete percentage.
    * @param {int} len The number of digits after the decimal point.
    */
    getCompletePercent(len?: number): number;
    
    /** Get average upload/download speed. */
    getAverageSpeed(): number;
    /** Get average upload/download speed. */
    getAverageSpeed(humanReadable: boolean): number | string;
    
    /** Get instant upload/download speed. */
    getSpeed(): number;
    /** Get instant upload/download speed. */
    getSpeed(humanReadable: boolean): number | string;
    
    /** Increment the complete data size. */
    increment(len: number): number;
    
    /** Get auto increment function. */
    getAutoIncrementFunction(size: number): (err: Error, result: any) => void;
    
    /** Get total size. */
    getTotalSize(): number;
    /** Get total size. */
    getTotalSize(humanReadable: boolean): number | string;
    
    /** Get completed data size. */
    getCompleteSize(): number;
    /** Get completed data size. */
    getCompleteSize(humanReadable: boolean): number | string;
}

export = SpeedSummary;
}
declare module 'azure-storage/lib/common/streams/speedsummary' {
import main = require('~azure-storage/lib/common/streams/speedsummary');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/util/constants.d.ts
declare module '~azure-storage/lib/common/util/constants' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/*
* Specifies the value to use for UserAgent header.
* @const
* @default "Azure-Storage"
*/
export const USER_AGENT_PRODUCT_NAME: string;

/*
* Specifies the value to use for UserAgent header.
* @const
* @default "0.10.0"
*/
export const USER_AGENT_PRODUCT_VERSION: string;

/**
* The number of default concurrent requests for parallel operation.
*
* @const
* @type {string}
*/
export const DEFAULT_PARALLEL_OPERATION_THREAD_COUNT: number;

/**
* Constant representing a kilobyte (Non-SI version).
*
* @const
* @type {string}
*/
export const KB: number;

/**
* Constant representing a megabyte (Non-SI version).
*
* @const
* @type {string}
*/
export const MB: number;

/**
* Constant representing a gigabyte (Non-SI version).
*
* @const
* @type {string}
*/
export const GB: number;

/**
* Specifies HTTP.
*
* @const
* @type {string}
* @default "http"
*/
export const HTTP: string;

/**
* Specifies HTTPS.
*
* @const
* @type {string}
* @default "https"
*/
export const HTTPS: string;

/**
* Default HTTP port.
*
* @const
* @type {int}
*/
export const DEFAULT_HTTP_PORT: number;

/**
* Default HTTPS port.
*
* @const
* @type {int}
*/
export const DEFAULT_HTTPS_PORT: number;

/**
* Marker for atom metadata.
*
* @const
* @type {string}
* @default "$"
*/
export const XML_METADATA_MARKER: string;

/**
* Marker for atom value.
*
* @const
* @type {string}
* @default "_"
*/
export const XML_VALUE_MARKER: string;

/**
* Defines the service types indicators.
* 
* @const
* @enum
*/
export const ServiceType: {
    /**
    * @const
    * @default "blob"
    */
    Blob: string;
    /**
    * @const
    * @default "queue"
    */
    Queue: string;
    /**
    * @const
    * @default "table"
    */
    Table: string;
    /**
    * @const
    * @default "file"
    */
    File: string;
};

/**
* Specifies the location used to indicate which location the operation can be performed against.
*
* @const
* @enum
*/
export const RequestLocationMode: {
    PRIMARY_ONLY: number;
    SECONDARY_ONLY: number;
    PRIMARY_OR_SECONDARY: number;
};

/**
* Represents a storage service location.
*
* @const
* @enum
*/
export const StorageLocation: {
    PRIMARY: number;
    SECONDARY: number;
};

export const AccountSasConstants: {
    /**
    * Permission types
    *
    * @const
    * @enum {string}
    */
    Permissions: {
        /**
        * @const
        * @default "r"
        */
        READ: string;
        /**
        * @const
        * @default "a"
        */
        ADD: string;
        /**
        * @const
        * @default "c"
        */
        CREATE: string;
        /**
        * @const
        * @default "u"
        */
        UPDATE: string;
        /**
        * @const
        * @default "p"
        */
        PROCESS: string;
        /**
        * @const
        * @default "w"
        */
        WRITE: string;
        /**
        * @const
        * @default "d"
        */
        DELETE: string;
        /**
        * @const
        * @default "l"
        */
        LIST: string;
    };

    /**
    * Services types
    *
    * @const
    * @enum {string}
    */
    Services: {
        /**
        * @const
        * @default "b"
        */
        BLOB: string;
        /**
        * @const
        * @default "f"
        */
        FILE: string;
        /**
        * @const
        * @default "q"
        */
        QUEUE: string;
        /**
        * @const
        * @default "t"
        */
        TABLE: string;
    };

    /**
    * Resources types
    *
    * @const
    * @enum {string}
    */
    Resources: {
        /**
        * @const
        * @default "s"
        */
        SERVICE: string;
        /**
        * @const
        * @default "c"
        */
        CONTAINER: string;
        /**
        * @const
        * @default "o"
        */
        OBJECT: string;
    };

    Protocols: {
        /**
        * @const
        * @default "https"
        */
        HTTPSONLY: string;
        /**
        * @const
        * @default "https;http"
        */
        HTTPSORHTTP: string;
    };
};

/**
* Defines constants for use with shared access policies.
*/
export const AclConstants: {
    /**
    * XML element for an access policy.
    *
    * @const
    * @type {string}
    * @default "AccessPolicy"
    */
    ACCESS_POLICY: string;

    /**
    * XML element for the end time of an access policy.
    *
    * @const
    * @type {string}
    * @default "Expiry"
    */
    EXPIRY: string;

    /**
    * XML attribute for IDs.
    *
    * @const
    * @type {string}
    * @default "Id"
    */
    ID: string;

    /**
    * XML element for the permission of an access policy.
    *
    * @const
    * @type {string}
    * @default "Permission"
    */
    PERMISSION: string;

    /**
    * XML element for a signed identifier.
    *
    * @const
    * @type {string}
    * @default "SignedIdentifier"
    */
    SIGNED_IDENTIFIER_ELEMENT: string;

    /**
    * XML element for signed identifiers.
    *
    * @const
    * @type {string}
    * @default "SignedIdentifiers"
    */
    SIGNED_IDENTIFIERS_ELEMENT: string;

    /**
    * XML element for the start time of an access policy.
    *
    * @const
    * @type {string}
    * @default "Start"
    */
    START: string;
};

/**
* Defines constants for use with service properties.
*/
export const ServicePropertiesConstants: {
    /**
    * XML element for storage service properties.
    *
    * @const
    * @type {string}
    * @default "StorageServiceProperties"
    */
    STORAGE_SERVICE_PROPERTIES_ELEMENT: string;

    /**
    * Default analytics version to send for logging; hour metrics and minute metrics.
    *
    * @const
    * @type {string}
    * @default "1.0"
    */
    DEFAULT_ANALYTICS_VERSION: string;

    /**
    * XML element for logging.
    *
    * @const
    * @type {string}
    * @default "Logging"
    */
    LOGGING_ELEMENT: string;

    /**
    * XML element for version.
    *
    * @const
    * @type {string}
    * @default "Version"
    */
    VERSION_ELEMENT: string;

    /**
    * XML element for delete.
    *
    * @const
    * @type {string}
    * @default "Delete"
    */
    DELETE_ELEMENT: string;

    /**
    * XML element for read.
    *
    * @const
    * @type {string}
    * @default "Read"
    */
    READ_ELEMENT: string;

    /**
    * XML element for write.
    *
    * @const
    * @type {string}
    * @default "Write"
    */
    WRITE_ELEMENT: string;

    /**
    * XML element for retention policy.
    *
    * @const
    * @type {string}
    * @default "RetentionPolicy"
    */
    RETENTION_POLICY_ELEMENT: string;

    /**
    * XML element for enabled.
    *
    * @const
    * @type {string}
    * @default "Enabled"
    */
    ENABLED_ELEMENT: string;

    /**
    * XML element for days.
    *
    * @const
    * @type {string}
    * @default "Days"
    */
    DAYS_ELEMENT: string;

    /**
    * XML element for HourMetrics.
    *
    * @const
    * @type {string}
    * @default "HourMetrics"
    */
    HOUR_METRICS_ELEMENT: string;

    /**
    * XML element for MinuteMetrics.
    *
    * @const
    * @type {string}
    * @default "MinuteMetrics"
    */
    MINUTE_METRICS_ELEMENT: string;

    /**
    * XML element for Cors.
    *
    * @const
    * @type {string}
    * @default "Cors"
    */
    CORS_ELEMENT: string;

    /**
    * XML element for CorsRule.
    *
    * @const
    * @type {string}
    * @default "CorsRule"
    */
    CORS_RULE_ELEMENT: string;

    /**
    * XML element for AllowedOrigins.
    *
    * @const
    * @type {string}
    * @default "AllowedOrigins"
    */
    ALLOWED_ORIGINS_ELEMENT: string;

    /**
    * XML element for AllowedMethods.
    *
    * @const
    * @type {string}
    * @default "AllowedMethods"
    */
    ALLOWED_METHODS_ELEMENT: string;

    /**
    * XML element for MaxAgeInSeconds.
    *
    * @const
    * @type {string}
    * @default "MaxAgeInSeconds"
    */
    MAX_AGE_IN_SECONDS_ELEMENT: string;

    /**
    * XML element for ExposedHeaders.
    *
    * @const
    * @type {string}
    * @default "ExposedHeaders"
    */
    EXPOSED_HEADERS_ELEMENT: string;

    /**
    * XML element for AllowedHeaders.
    *
    * @const
    * @type {string}
    * @default "AllowedHeaders"
    */
    ALLOWED_HEADERS_ELEMENT: string;

    /**
    * XML element for IncludeAPIs.
    *
    * @const
    * @type {string}
    * @default "IncludeAPIs"
    */
    INCLUDE_APIS_ELEMENT: string;

    /**
    * XML element for DefaultServiceVersion.
    *
    * @const
    * @type {string}
    * @default "DefaultServiceVersion"
    */
    DEFAULT_SERVICE_VERSION_ELEMENT: string;
};

/**
* Defines constants for use with blob operations.
*/
export const BlobConstants: {
    /**
    * XML element for the latest.
    *
    * @const
    * @type {string}
    * @default "Latest"
    */
    LATEST_ELEMENT: string;

    /**
    * XML element for uncommitted blocks.
    *
    * @const
    * @type {string}
    * @default "Uncommitted"
    */
    UNCOMMITTED_ELEMENT: string;

    /**
    * XML element for a block list.
    *
    * @const
    * @type {string}
    * @default "BlockList"
    */
    BLOCK_LIST_ELEMENT: string;

    /**
    * XML element for committed blocks.
    *
    * @const
    * @type {string}
    * @default "Committed"
    */
    COMMITTED_ELEMENT: string;

    /**
    * The default write page size; in bytes; used by blob streams.
    *
    * @const
    * @type {int}
    */
    DEFAULT_WRITE_PAGE_SIZE_IN_BYTES: number;

    /**
    * The minimum write page size; in bytes; used by blob streams.
    *
    * @const
    * @type {int}
    */
    MIN_WRITE_PAGE_SIZE_IN_BYTES: number;

    /**
    * The default maximum size; in bytes; of a blob before it must be separated into blocks.
    *
    * @const
    * @type {int}
    */
    DEFAULT_SINGLE_BLOB_PUT_THRESHOLD_IN_BYTES: number;

    /**
    * The default write block size; in bytes; used by blob streams.
    *
    * @const
    * @type {int}
    */
    DEFAULT_WRITE_BLOCK_SIZE_IN_BYTES: number;

    /**
    * The maximum size of a single block.
    *
    * @const
    * @type {int}
    */
    MAX_BLOCK_SIZE: number;

    /**
    * The maximum size; in bytes; of a blob before it must be separated into blocks.
    *
    * @const
    * @type {int}
    */
    MAX_SINGLE_UPLOAD_BLOB_SIZE_IN_BYTES: number;

    /**
    * The maximum range get size when requesting for a contentMD5
    */
    MAX_RANGE_GET_SIZE_WITH_MD5: number;

    /**
    * The maximum page range size for a page update operation.
    */
    MAX_UPDATE_PAGE_SIZE: number;

    /**
    * The maximum buffer size for writing a stream buffer.
    */
    MAX_QUEUED_WRITE_DISK_BUFFER_SIZE: number;

    /**
    * Max size for single get page range. The max value should be 150MB
    * http://blogs.msdn.com/b/windowsazurestorage/archive/2012/03/26/getting-the-page-ranges-of-a-large-page-blob-in-segments.aspx
    */
    MAX_SINGLE_GET_PAGE_RANGE_SIZE: number;

    /**
    * The size of a page; in bytes; in a page blob.
    */
    PAGE_SIZE: number;

    /**
    * Resource types.
    *
    * @const
    * @enum {string}
    */
    ResourceTypes: {
        /**
        * @const
        * @default "c"
        */
        CONTAINER: string;
        /**
        * @const
        * @default "b"
        */
        BLOB: string;
    };

    /**
    * List blob types.
    *
    * @const
    * @enum {string}
    */
    ListBlobTypes: {
        /**
        * @const
        * @default "b"
        */
        Blob: string;
        /**
        * @const
        * @default "d"
        */
        Directory: string;
    };

    /**
    * Put page write options
    *
    * @const
    * @enum {string}
    */
    PageWriteOptions: {
        /**
        * @const
        * @default "update"
        */
        UPDATE: string;
        /**
        * @const
        * @default "clear"
        */
        CLEAR: string;
    };

    /**
    * Blob types
    *
    * @const
    * @enum {string}
    */
    BlobTypes: {
        /**
        * @const
        * @default "BlockBlob"
        */
        BLOCK: string;
        /**
        * @const
        * @default "PageBlob"
        */
        PAGE: string;
        /**
        * @const
        * @default "AppendBlob"
        */
        APPEND: string;
    };

    /**
    * Blob lease constants
    *
    * @const
    * @enum {string}
    */
    LeaseOperation: {
        /**
        * @const
        * @default "acquire"
        */
        ACQUIRE: string;
        /**
        * @const
        * @default "renew"
        */
        RENEW: string;
        /**
        * @const
        * @default "change"
        */
        CHANGE: string;
        /**
        * @const
        * @default "release"
        */
        RELEASE: string;
        /**
        * @const
        * @default "break"
        */
        BREAK: string;
    }
};

/**
* Defines constants for use with file operations.
*/
export const FileConstants: {
    /**
    * The default write size; in bytes; used by file streams.
    *
    * @const
    * @type {string}
    */
    DEFAULT_WRITE_SIZE_IN_BYTES: number;

    /**
    * The maximum range size when requesting for a contentMD5.
    */
    MAX_RANGE_GET_SIZE_WITH_MD5: number;

    /**
    * The maximum range size for a file update operation.
    */
    MAX_UPDATE_FILE_SIZE: number;

    /**
    * The default minimum size; in bytes; of a file when it must be separated into ranges.
    *
    * @const
    * @type {int}
    */
    DEFAULT_SINGLE_FILE_GET_THRESHOLD_IN_BYTES: number;

    /**
    * The minimum write file size; in bytes; used by file streams.
    *
    * @const
    * @type {int}
    */
    MIN_WRITE_FILE_SIZE_IN_BYTES: number;

    /**
    * Put range write options
    *
    * @const
    * @enum {string}
    */
    RangeWriteOptions: {
        /**
        * @const
        * @default "update"
        */
        UPDATE: string;
        /**
        * @const
        * @default "clear"
        */
        CLEAR: string;
    };

    /**
    * Resource types.
    *
    * @const
    * @enum {string}
    */
    ResourceTypes: {
        /**
        * @const
        * @default "s"
        */
        SHARE: string;
        /**
        * @const
        * @default "f"
        */
        FILE: string;
    }
};

/**
* Defines constants for use with queue storage.
*
* @const
* @type {string}
*/
export const QueueConstants: {
    /**
    * XML element for QueueMessage.
    *
    * @const
    * @type {string}
    * @default "QueueMessage"
    */
    QUEUE_MESSAGE_ELEMENT: string;

    /**
    * XML element for MessageText.
    *
    * @const
    * @type {string}
    * @default "MessageText"
    */
    MESSAGE_TEXT_ELEMENT: string;
};

/**
* Defines constants for use with table storage.
*
* @const
* @type {string}
*/
export const TableConstants: {
    /**
    * The changeset response delimiter.
    *
    * @const
    * @type {string}
    * @default "--changesetresponse_"
    */
    CHANGESET_DELIMITER: string;

    /**
    * The batch response delimiter.
    *
    * @const
    * @type {string}
    * @default "--batchresponse_"
    */
    BATCH_DELIMITER: string;

    /**
    * The next continuation row key token.
    *
    * @const
    * @type {string}
    * @default "x-ms-continuation-nextrowkey"
    */
    CONTINUATION_NEXT_ROW_KEY: string;

    /**
    * The next continuation partition key token.
    *
    * @const
    * @type {string}
    * @default "x-ms-continuation-nextpartitionkey"
    */
    CONTINUATION_NEXT_PARTITION_KEY: string;

    /**
    * The next continuation table name token.
    *
    * @const
    * @type {string}
    * @default "x-ms-continuation-nexttablename"
    */
    CONTINUATION_NEXT_TABLE_NAME: string;

    /**
    * The next row key query string argument.
    *
    * @const
    * @type {string}
    * @default "NextRowKey"
    */
    NEXT_ROW_KEY: string;

    /**
* The next partition key query string argument.
*
* @const
* @type {string}
    * @default "NextPartitionKey"
    */
    NEXT_PARTITION_KEY: string;

    /**
    * The next table name query string argument.
    *
    * @const
    * @type {string}
    * @default "NextTableName"
    */
    NEXT_TABLE_NAME: string;

    /** 
    * Prefix of the odata properties returned in a JSON query
    * @default "odata."
    */
    ODATA_PREFIX: string;

    /**
    * Constant representing the string following a type annotation in a JSON table query
    * @default "@odata.type"
    */
    ODATA_TYPE_SUFFIX: string;

    /**
    * Constant representing the property where the odata metadata elements are stored.
    *
    * @const
    * @type {string}
    * @default ".metadata"
    */
    ODATA_METADATA_MARKER: string;

    /**
    * Constant representing the value for an entity property.
    * @default "_"
    */
    ODATA_VALUE_MARKER: string;

    /** 
    * Constant representing the type for an entity property.
    * @default "$"
    */
    ODATA_TYPE_MARKER: string;

    /**
    * The value to set the maximum data service version header.
    * @const
    * @type {string}
    * @default "3.0;NetFx"
    */
    DEFAULT_DATA_SERVICE_VERSION: string;

    /**
    * The name of the property that stores the table name.
    *
    * @const
    * @type {string}
    * @default "TableName"
    */
    TABLE_NAME: string;

    /**
    * The name of the special table used to store tables.
    *
    * @const
    * @type {string}
    * @default "Tables"
    */
    TABLE_SERVICE_TABLE_NAME: string;

    /**
    * Operations
    *
    * @const
    * @enum {string}
    */
    Operations: {
        /**
        * @const
        * @default "RETRIEVE"
        */
        RETRIEVE: string;
        /**
        * @const
        * @default "INSERT"
        */
        INSERT: string;
        /**
        * @const
        * @default "REPLACE"
        */
        REPLACE: string;
        /**
        * @const
        * @default "MERGE"
        */
        MERGE: string;
        /**
        * @const
        * @default "DELETE"
        */
        DELETE: string;
        /**
        * @const
        * @default "INSERT_OR_REPLACE"
        */
        INSERT_OR_REPLACE: string;
        /**
        * @const
        * @default "INSERT_OR_MERGE"
        */
        INSERT_OR_MERGE: string;
    }
};

/**
* Defines constants for use with HTTP headers.
*/
export const HeaderConstants: {
    /**
    * The accept ranges header.
    *
    * @const
    * @type {string}
    * @default "accept_ranges"
    */
    ACCEPT_RANGES: string;

    /**
    * The content transfer encoding header.
    *
    * @const
    * @type {string}
    * @default "content-transfer-encoding"
    */
    CONTENT_TRANSFER_ENCODING: string;

    /**
    * The transfer encoding header.
    *
    * @const
    * @type {string}
    * @default "transfer-encoding"
    */
    TRANSFER_ENCODING: string;

    /**
    * The server header.
    *
    * @const
    * @type {string}
    * @default "server"
    */
    SERVER: string;

    /**
    * The location header.
    *
    * @const
    * @type {string}
    * @default "location"
    */
    LOCATION: string;

    /**
    * The Last-Modified header
    *
    * @const
    * @type {string}
    * @default "Last-Modified"
    */
    LAST_MODIFIED: string;

    /**
    * The data service version.
    *
    * @const
    * @type {string}
    * @default "dataserviceversion"
    */
    DATA_SERVICE_VERSION: string;

    /**
    * The maximum data service version.
    *
    * @const
    * @type {string}
    * @default "maxdataserviceversion"
    */
    MAX_DATA_SERVICE_VERSION: string;

    /**
    * The master Windows Azure Storage header prefix.
    *
    * @const
    * @type {string}
    * @default "x-ms-"
    */
    PREFIX_FOR_STORAGE: string;

    /**
    * The client request Id header.
    *
    * @const
    * @type {string}
    * @default "x-ms-client-request-id"
    */
    CLIENT_REQUEST_ID: string;

    /**
    * The header that specifies the approximate message count of a queue.
    *
    * @const
    * @type {string}
    * @default "x-ms-approximate-messages-count"
    */
    APPROXIMATE_MESSAGES_COUNT: string;

    /**
    * The Authorization header.
    *
    * @const
    * @type {string}
    * @default "authorization"
    */
    AUTHORIZATION: string;

    /**
    * The header that specifies public access to blobs.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-public-access"
    */
    BLOB_PUBLIC_ACCESS: string;

    /**
    * The header for the blob type.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-type"
    */
    BLOB_TYPE: string;

    /**
    * The header for the type.
    *
    * @const
    * @type {string}
    * @default "x-ms-type"
    */
    TYPE: string;

    /**
    * Specifies the block blob type.
    *
    * @const
    * @type {string}
    * @default "blockblob"
    */
    BLOCK_BLOB: string;

    /**
    * The CacheControl header.
    *
    * @const
    * @type {string}
    * @default "cache-control"
    */
    CACHE_CONTROL: string;

    /**
    * The header that specifies blob caching control.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-cache-control"
    */
    BLOB_CACHE_CONTROL: string;

    /**
    * The header that specifies caching control.
    *
    * @const
    * @type {string}
    * @default "x-ms-cache-control"
    */
    FILE_CACHE_CONTROL: string;

    /**
    * The copy status.
    *
    * @const
    * @type {string}
    * @default "x-ms-copy-status"
    */
    COPY_STATUS: string;

    /**
    * The copy completion time
    *
    * @const
    * @type {string}
    * @default "x-ms-copy-completion-time"
    */
    COPY_COMPLETION_TIME: string;

    /**
    * The copy status message
    *
    * @const
    * @type {string}
    * @default "x-ms-copy-status-description"
    */
    COPY_STATUS_DESCRIPTION: string;

    /**
    * The copy identifier.
    *
    * @const
    * @type {string}
    * @default "x-ms-copy-id"
    */
    COPY_ID: string;

    /**
    * Progress of any copy operation
    *
    * @const
    * @type {string}
    * @default "x-ms-copy-progress"
    */
    COPY_PROGRESS: string;

    /**
    * The copy action.
    *
    * @const
    * @type {string}
    * @default "x-ms-copy-action"
    */
    COPY_ACTION: string;

    /**
    * The ContentID header.
    *
    * @const
    * @type {string}
    * @default "content-id"
    */
    CONTENT_ID: string;

    /**
    * The ContentEncoding header.
    *
    * @const
    * @type {string}
    * @default "content-encoding"
    */
    CONTENT_ENCODING: string;

    /**
    * The header that specifies blob content encoding.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-content-encoding"
    */
    BLOB_CONTENT_ENCODING: string;

    /**
    * The header that specifies content encoding.
    *
    * @const
    * @type {string}
    * @default "x-ms-content-encoding"
    */
    FILE_CONTENT_ENCODING: string;

    /**
    * The ContentLangauge header.
    *
    * @const
    * @type {string}
    * @default "content-language"
    */
    CONTENT_LANGUAGE: string;

    /**
    * The header that specifies blob content language.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-content-language"
    */
    BLOB_CONTENT_LANGUAGE: string;

    /**
    * The header that specifies content language.
    *
    * @const
    * @type {string}
    * @default "x-ms-content-language"
    */
    FILE_CONTENT_LANGUAGE: string;

    /**
    * The ContentLength header.
    *
    * @const
    * @type {string}
    * @default "content-length"
    */
    CONTENT_LENGTH: string;

    /**
    * The header that specifies blob content length.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-content-length"
    */
    BLOB_CONTENT_LENGTH: string;

    /**
    * The header that specifies content length.
    *
    * @const
    * @type {string}
    * @default "x-ms-content-length"
    */
    FILE_CONTENT_LENGTH: string;

    /**
    * The ContentDisposition header.
    * @const
    * @type {string}
    * @default "content-disposition"
    */
    CONTENT_DISPOSITION: string;

    /**
    * The header that specifies blob content disposition.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-content-disposition"
    */
    BLOB_CONTENT_DISPOSITION: string;

    /**
    * The header that specifies content disposition.
    *
    * @const
    * @type {string}
    * @default "x-ms-content-disposition"
    */
    FILE_CONTENT_DISPOSITION: string;

    /**
    * The ContentMD5 header.
    *
    * @const
    * @type {string}
    */
    CONTENT_MD5: "content-md5";

    /**
    * The header that specifies blob content MD5.
    *
    * @const
    * @type {string}
    */
    BLOB_CONTENT_MD5: "x-ms-blob-content-md5";

    /**
    * The header that specifies content MD5.
    *
    * @const
    * @type {string}
    */
    FILE_CONTENT_MD5: "x-ms-content-md5";

    /**
    * The ContentRange header.
    *
    * @const
    * @type {string}
    * @default "cache-range"
    */
    CONTENT_RANGE: string;

    /**
    * The ContentType header.
    *
    * @const
    * @type {string}
    * @default "content-type"
    */
    CONTENT_TYPE: string;

    /**
    * The header that specifies blob content type.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-content-type"
    */
    BLOB_CONTENT_TYPE: string;

    /**
    * The header that specifies content type.
    *
    * @const
    * @type {string}
    * @default "x-ms-content-type"
    */
    FILE_CONTENT_TYPE: string;

    /**
    * The header for copy source.
    *
    * @const
    * @type {string}
    * @default "x-ms-copy-source"
    */
    COPY_SOURCE: string;

    /**
    * The header that specifies the date.
    *
    * @const
    * @type {string}
    * @default "date"
    */
    DATE: string;

    /**
    * The header that specifies the date.
    *
    * @const
    * @type {string}
    * @default "x-ms-date"
    */
    MS_DATE: string;

    /**
    * The header to delete snapshots.
    *
    * @const
    * @type {string}
    * @default "x-ms-delete-snapshots"
    */
    DELETE_SNAPSHOT: string;

    /**
    * The ETag header.
    *
    * @const
    * @type {string}
    * @default "etag"
    */
    ETAG: string;

    /**
    * The IfMatch header.
    *
    * @const
    * @type {string}
    * @default "if-match"
    */
    IF_MATCH: string;

    /**
    * The IfModifiedSince header.
    *
    * @const
    * @type {string}
    * @default "if-modified-since"
    */
    IF_MODIFIED_SINCE: string;

    /**
    * The IfNoneMatch header.
    *
    * @const
    * @type {string}
    * @default "if-none-match"
    */
    IF_NONE_MATCH: string;

    /**
    * The IfUnmodifiedSince header.
    *
    * @const
    * @type {string}
    * @default "if-unmodified-since"
    */
    IF_UNMODIFIED_SINCE: string;

    /**
    * Specifies snapshots are to be included.
    *
    * @const
    * @type {string}
    * @default "include"
    */
    INCLUDE_SNAPSHOTS_VALUE: string;

    /**
    * Specifies that the content-type is JSON.
    *
    * @const
    * @type {string}
    * @default "application/json;"
    */
    JSON_CONTENT_TYPE_VALUE: string;


    /**
    * The header that specifies lease ID.
    *
    * @const
    * @type {string}
    * @default "x-ms-lease-id"
    */
    LEASE_ID: string;

    /**
    * The header that specifies the lease break period.
    *
    * @const
    * @type {string}
    * @default "x-ms-lease-break-period"
    */
    LEASE_BREAK_PERIOD: string;

    /**
    * The header that specifies the proposed lease identifier.
    *
    * @const
    * @type {string}
    * @default "x-ms-proposed-lease-id"
    */
    PROPOSED_LEASE_ID: string;

    /**
    * The header that specifies the lease duration.
    *
    * @const
    * @type {string}
    * @default "x-ms-lease-duration"
    */
    LEASE_DURATION: string;

    /**
    * The header that specifies the source lease ID.
    *
    * @const
    * @type {string}
    * @default "x-ms-source-lease-id"
    */
    SOURCE_LEASE_ID: string;

    /**
    * The header that specifies lease time.
    *
    * @const
    * @type {string}
    * @default "x-ms-lease-time"
    */
    LEASE_TIME: string;

    /**
    * The header that specifies lease status.
    *
    * @const
    * @type {string}
    * @default "x-ms-lease-status"
    */
    LEASE_STATUS: string;

    /**
    * The header that specifies lease state.
    *
    * @const
    * @type {string}
    * @default "x-ms-lease-state"
    */
    LEASE_STATE: string;

    /**
    * Specifies the page blob type.
    *
    * @const
    * @type {string}
    * @default "PageBlob"
    */
    PAGE_BLOB: string;

    /**
    * The header that specifies page write mode.
    *
    * @const
    * @type {string}
    * @default "x-ms-page-write"
    */
    PAGE_WRITE: string;

    /**
    * The header that specifies file range write mode.
    *
    * @const
    * @type {string}
    * @default "x-ms-write"
    */
    FILE_WRITE: string;

    /**
    * The header that specifies whether the response should include the inserted entity.
    *
    * @const
    * @type {string}
    * @default "Prefer"
    */
    PREFER: string;

    /**
    * The header value which specifies that the response should include the inserted entity.
    *
    * @const
    * @type {string}
    * @default "return-content"
    */
    PREFER_CONTENT: string;

    /**
    * The header value which specifies that the response should not include the inserted entity.
    *
    * @const
    * @type {string}
    * @default "return-no-content"
    */
    PREFER_NO_CONTENT: string;

    /**
    * The header prefix for metadata.
    *
    * @const
    * @type {string}
    * @default "x-ms-meta-"
    */
    PREFIX_FOR_STORAGE_METADATA: string;

    /**
    * The header prefix for properties.
    *
    * @const
    * @type {string}
    * @default "x-ms-prop-"
    */
    PREFIX_FOR_STORAGE_PROPERTIES: string;

    /**
    * The Range header.
    *
    * @const
    * @type {string}
    * @default "Range"
    */
    RANGE: string;

    /**
    * The header that specifies if the request will populate the ContentMD5 header for range gets.
    *
    * @const
    * @type {string}
    */
    RANGE_GET_CONTENT_MD5: "x-ms-range-get-content-md5";

    /**
    * The format string for specifying ranges.
    *
    * @const
    * @type {string}
    * @default "bytes:%d-%d"
    */
    RANGE_HEADER_FORMAT: string;

    /**
    * The header that indicates the request ID.
    *
    * @const
    * @type {string}
    * @default "x-ms-request-id"
    */
    REQUEST_ID: string;

    /**
    * The header for specifying the sequence number.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-sequence-number"
    */
    SEQUENCE_NUMBER: string;

    /**
    * The header for specifying the If-Sequence-Number-EQ condition.
    *
    * @const
    * @type {string}
    * @default "x-ms-if-sequence-number-eq"
    */
    SEQUENCE_NUMBER_EQUAL: string;

    /**
    * The header for specifying the If-Sequence-Number-LT condition.
    *
    * @const
    * @type {string}
    * @default "x-ms-if-sequence-number-lt"
    */
    SEQUENCE_NUMBER_LESS_THAN: string;

    /**
    * The header for specifying the If-Sequence-Number-LE condition.
    *
    * @const
    * @type {string}
    * @default "x-ms-if-sequence-number-le"
    */
    SEQUENCE_NUMBER_LESS_THAN_OR_EQUAL: string;

    /**
    * The header that specifies sequence number action.
    *
    * @const
    * @type {string}
    * @default "x-ms-sequence-number-action"
    */
    SEQUENCE_NUMBER_ACTION: string;

    /**
    * The header for the blob content length.
    *
    * @const
    * @type {string}
    * @default "x-ms-blob-content-length"
    */
    SIZE: string;

    /**
    * The header for snapshots.
    *
    * @const
    * @type {string}
    * @default "x-ms-snapshot"
    */
    SNAPSHOT: string;

    /**
    * Specifies only snapshots are to be included.
    *
    * @const
    * @type {string}
    * @default "only"
    */
    SNAPSHOTS_ONLY_VALUE: string;

    /**
    * The header for the If-Match condition.
    *
    * @const
    * @type {string}
    * @default "x-ms-source-if-match"
    */
    SOURCE_IF_MATCH: string;

    /**
    * The header for the If-Modified-Since condition.
    *
    * @const
    * @type {string}
    * @default "x-ms-source-if-modified-since"
    */
    SOURCE_IF_MODIFIED_SINCE: string;

    /**
    * The header for the If-None-Match condition.
    *
    * @const
    * @type {string}
    * @default "x-ms-source-if-none-match"
    */
    SOURCE_IF_NONE_MATCH: string;

    /**
    * The header for the If-Unmodified-Since condition.
    *
    * @const
    * @type {string}
    * @default "x-ms-source-if-unmodified-since"
    */
    SOURCE_IF_UNMODIFIED_SINCE: string;

    /**
    * The header for data ranges.
    *
    * @const
    * @type {string}
    * @default "x-ms-range"
    */
    STORAGE_RANGE: string;

    /**
    * The header for storage version.
    *
    * @const
    * @type {string}
    * @default "x-ms-version"
    */
    STORAGE_VERSION: string;

    /**
    * The current storage version header value.
    *
    * @const
    * @type {string}
    * @default "2015-04-05"
    */
    TARGET_STORAGE_VERSION: string;

    /**
    * The UserAgent header.
    *
    * @const
    * @type {string}
    * @default "user-agent"
    */
    USER_AGENT: string;

    /**
    * The pop receipt header.
    *
    * @const
    * @type {string}
    * @default "x-ms-popreceipt"
    */
    POP_RECEIPT: string;

    /**
    * The time next visibile header.
    *
    * @const
    * @type {string}
    * @default "x-ms-time-next-visible"
    */
    TIME_NEXT_VISIBLE: string;

    /**
    * The approximate message counter header.
    *
    * @const
    * @type {string}
    * @default "x-ms-approximate-message-count"
    */
    APPROXIMATE_MESSAGE_COUNT: string;

    /**
    * The lease action header.
    *
    * @const
    * @type {string}
    * @default "x-ms-lease-action"
    */
    LEASE_ACTION: string;

    /**
    * The accept header.
    *
    * @const
    * @type {string}
    * @default "accept"
    */
    ACCEPT: string;

    /**
    * The accept charset header.
    *
    * @const
    * @type {string}
    * @default "Accept-Charset"
    */
    ACCEPT_CHARSET: string;

    /**
    * The host header.
    *
    * @const
    * @type {string}
    * @default "host"
    */
    HOST: string;

    /**
    * The correlation identifier header.
    *
    * @const
    * @type {string}
    * @default "x-ms-correlation-id"
    */
    CORRELATION_ID: string;

    /**
    * The group identifier header.
    *
    * @const
    * @type {string}
    * @default "x-ms-group-id"
    */
    GROUP_ID: string;

    /**
    * The share quota header.
    *
    * @const
    * @type {string}
    * @default "x-ms-share-quota"
    */
    SHARE_QUOTA: string;

    /**
    * The max blob size header.
    *
    * @const
    * @type {int}
    * @default "x-ms-blob-condition-maxsize"
    */
    BLOB_CONDITION_MAX_SIZE: string;

    /**
    * The append blob position header.
    *
    * @const
    * @type {int}
    * @default "x-ms-blob-condition-appendpos"
    */
    BLOB_CONDITION_APPEND_POSITION: string;

    /**
    * The append blob append offset header.
    *
    * @const
    * @type {int}
    * @default "x-ms-blob-append-offset"
    */
    BLOB_APPEND_OFFSET: string;

    /**
    * The append blob committed block header.
    *
    * @const
    * @type {int}
    * @default "x-ms-blob-committed-block-count"
    */
    BLOB_COMMITTED_BLOCK_COUNT: string;
};

export const QueryStringConstants: {

    /**
    * Query component for SAS API version.
    * @const
    * @type {string}
    * @default "api-version"
    */
    API_VERSION: string;

    /**
    * The Comp value.
    *
    * @const
    * @type {string}
    * @default "comp"
    */
    COMP: string;

    /**
    * The Res Type.
    *
    * @const
    * @type {string}
    * @default "restype"
    */
    RESTYPE: string;

    /**
    * The copy Id.
    * @const
    * @type {string}
    * @default "copyid"
    */
    COPY_ID: string;

    /**
    * The Snapshot value.
    *
    * @const
    * @type {string}
    * @default "snapshot"
    */
    SNAPSHOT: string;

    /**
    * The timeout value.
    *
    * @const
    * @type {string}
    * @default "timeout"
    */
    TIMEOUT: string;

    /**
    * The signed start time query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "st"
    */
    SIGNED_START: string;

    /**
    * The signed expiry time query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "se"
    */
    SIGNED_EXPIRY: string;

    /**
    * The signed resource query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "sr"
    */
    SIGNED_RESOURCE: string;

    /**
    * The signed permissions query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "sp"
    */
    SIGNED_PERMISSIONS: string;

    /**
    * The signed services query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "ss"
    */
    SIGNED_SERVICES: string;

    /**
    * The signed resource types query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "srt"
    */
    SIGNED_RESOURCE_TYPES: string;

    /**
    * The signed IP query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "sip"
    */
    SIGNED_IP: string;

    /**
    * The signed protocol query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "spr"
    */
    SIGNED_PROTOCOL: string;

    /**
    * The signed identifier query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "si"
    */
    SIGNED_IDENTIFIER: string;

    /**
    * The signature query string argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "sig"
    */
    SIGNATURE: string;

    /**
    * The signed version argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "sv"
    */
    SIGNED_VERSION: string;

    /**
    * The cache control argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "rscc"
    */
    CACHE_CONTROL: string;

    /**
    * The content type argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "rsct"
    */
    CONTENT_TYPE: string;

    /**
    * The content encoding argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "rsce"
    */
    CONTENT_ENCODING: string;

    /**
    * The content language argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "rscl"
    */
    CONTENT_LANGUAGE: string;

    /**
    * The content disposition argument for shared access signature.
    *
    * @const
    * @type {string}
    * @default "rscd"
    */
    CONTENT_DISPOSITION: string;

    /**
    * The block identifier query string argument for blob service.
    *
    * @const
    * @type {string}
    * @default "blockid"
    */
    BLOCK_ID: string;

    /**
    * The block list type query string argument for blob service.
    *
    * @const
    * @type {string}
    * @default "blocklisttype"
    */
    BLOCK_LIST_TYPE: string;

    /**
    * The prefix query string argument for listing operations.
    *
    * @const
    * @type {string}
    * @default "prefix"
    */
    PREFIX: string;

    /**
    * The marker query string argument for listing operations.
    *
    * @const
    * @type {string}
    * @default "marker"
    */
    MARKER: string;

    /**
    * The maxresults query string argument for listing operations.
    *
    * @const
    * @type {string}
    * @default "maxresults"
    */
    MAX_RESULTS: string;

    /**
    * The delimiter query string argument for listing operations.
    *
    * @const
    * @type {string}
    * @default "delimiter"
    */
    DELIMITER: string;

    /**
    * The include query string argument for listing operations.
    *
    * @const
    * @type {string}
    * @default "include"
    */
    INCLUDE: string;

    /**
    * The peekonly query string argument for queue service.
    *
    * @const
    * @type {string}
    * @default "peekonly"
    */
    PEEK_ONLY: string;

    /**
    * The numofmessages query string argument for queue service.
    *
    * @const
    * @type {string}
    * @default "numofmessages"
    */
    NUM_OF_MESSAGES: string;

    /**
    * The popreceipt query string argument for queue service.
    *
    * @const
    * @type {string}
    * @default "popreceipt"
    */
    POP_RECEIPT: string;

    /**
    * The visibilitytimeout query string argument for queue service.
    *
    * @const
    * @type {string}
    * @default "visibilitytimeout"
    */
    VISIBILITY_TIMEOUT: string;

    /**
    * The messagettl query string argument for queue service.
    *
    * @const
    * @type {string}
    * @default "messagettl"
    */
    MESSAGE_TTL: string;

    /**
    * The select query string argument.
    *
    * @const
    * @type {string}
    * @default "$select"
    */
    SELECT: string;

    /**
    * The filter query string argument.
    *
    * @const
    * @type {string}
    * @default "$filter"
    */
    FILTER: string;

    /**
    * The top query string argument.
    *
    * @const
    * @type {string}
    * @default "$top"
    */
    TOP: string;

    /**
    * The skip query string argument.
    *
    * @const
    * @type {string}
    * @default "$skip"
    */
    SKIP: string;

    /**
    * The next partition key query string argument for table service.
    *
    * @const
    * @type {string}
    * @default "NextPartitionKey"
    */
    NEXT_PARTITION_KEY: string;

    /**
    * The next row key query string argument for table service.
    *
    * @const
    * @type {string}
    * @default "NextRowKey"
    */
    NEXT_ROW_KEY: string;

    /**
    * The lock identifier for service bus messages.
    *
    * @const
    * @type {string}
    * @default "lockid"
    */
    LOCK_ID: string;

    /**
    * The table name for table SAS URI"s.
    *
    * @const
    * @type {string}
    * @default "tn"
    */
    TABLENAME: string;

    /**
    * The starting Partition Key for tableSAS URI"s.
    *
    * @const
    * @type {string}
    * @default "spk"
    */
    STARTPK: string;

    /**
    * The starting Partition Key for tableSAS URI"s.
    *
    * @const
    * @type {string}
    * @default "srk"
    */
    STARTRK: string;

    /**
    * The ending Partition Key for tableSAS URI"s.
    *
    * @const
    * @type {string}
    * @default "epk"
    */
    ENDPK: string;

    /**
    * The ending Partition Key for tableSAS URI"s.
    *
    * @const
    * @type {string}
    * @default "erk"
    */
    ENDRK: string;
};

export const StorageServiceClientConstants: {
    /**
    * The default protocol.
    * @default "https:"
    */
    DEFAULT_PROTOCOL: string;

    /*
    * Used environment variables.
    * @enum {string}
    */
    EnvironmentVariables: {
        /**
        * @const
        * @default "AZURE_STORAGE_ACCOUNT"
        */
        AZURE_STORAGE_ACCOUNT: string;
        /**
        * @const
        * @default "AZURE_STORAGE_ACCESS_KEY"
        */
        AZURE_STORAGE_ACCESS_KEY: string;
        /**
        * @const
        * @default "AZURE_STORAGE_DNS_SUFFIX"
        */
        AZURE_STORAGE_DNS_SUFFIX: string;
        /**
        * @const
        * @default "AZURE_STORAGE_CONNECTION_STRING"
        */
        AZURE_STORAGE_CONNECTION_STRING: string;
        /**
        * @const
        * @default "HTTP_PROXY"
        */
        HTTP_PROXY: string;
        /**
        * @const
        * @default "HTTPS_PROXY"
        */
        HTTPS_PROXY: string;
        /**
        * @const
        * @default "EMULATED"
        */
        EMULATED: string;
    };

    /**
    * Default credentials.
    * @default "devstoreaccount1"
    */
    DEVSTORE_STORAGE_ACCOUNT: string;
    /**
    * @const
    * @default "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw=="
    */
    DEVSTORE_STORAGE_ACCESS_KEY: string;

    /**
    * The development store URI.
    *
    * @const
    * @type {string}
    * @default "http://127.0.0.1"
    */
    DEV_STORE_URI: string;

    /**
    * Development ServiceClient URLs.
    * @default "http://"
    */
    DEVSTORE_DEFAULT_PROTOCOL: string;
    /**
    * @const
    * @default "127.0.0.1:10000"
    */
    DEVSTORE_BLOB_HOST: string;
    /**
    * @const
    * @default "127.0.0.1:10001"
    */
    DEVSTORE_QUEUE_HOST: string;
    /**
    * @const
    * @default "127.0.0.1:10002"
    */
    DEVSTORE_TABLE_HOST: string;

    /**
    * Production ServiceClient URLs.
    * @default "blob.core.windows.net"
    */
    CLOUD_BLOB_HOST: string;
    /**
    * @const
    * @default "queue.core.windows.net"
    */
    CLOUD_QUEUE_HOST: string;
    /**
    * @const
    * @default "table.core.windows.net"
    */
    CLOUD_TABLE_HOST: string;
    /**
    * @const
    * @default "file.core.windows.net"
    */
    CLOUD_FILE_HOST: string;
};

export const HttpConstants: {
    /**
    * Http Verbs
    *
    * @const
    * @enum {string}
    */
    HttpVerbs: {
        /**
        * @const
        * @default "PUT"
        */
        PUT: string;
        /**
        * @const
        * @default "GET"
        */
        GET: string;
        /**
        * @const
        * @default "DELETE"
        */
        DELETE: string;
        /**
        * @const
        * @default "POST"
        */
        POST: string;
        /**
        * @const
        * @default "MERGE"
        */
        MERGE: string;
        /**
        * @const
        * @default "HEAD"
        */
        HEAD: string;
    };

    /**
    * Response codes.
    *
    * @const
    * @enum {int}
    */
    HttpResponseCodes: {
        Ok: number;
        Created: number;
        Accepted: number;
        NoContent: number;
        PartialContent: number;
        BadRequest: number;
        Unauthorized: number;
        Forbidden: number;
        NotFound: number;
        Conflict: number;
        LengthRequired: number;
        PreconditionFailed: number;
    }
};

export const CompatibleVersionConstants: {
    /**
    * Constant for the 2015-04-05 version.
    *
    * @const
    * @type {string}
    */
    APRIL_2015: "2015-04-05";

    /**
    * Constant for the 2013-08-15 version.
    *
    * @const
    * @type {string}
    */
    AUGUST_2013: "2013-08-15";

    /**
    * Constant for the 2012-02-12 version.
    *
    * @const
    * @type {string}
    */
    FEBRUARY_2012: "2012-02-12";
};

export const BlobErrorCodeStrings: {
    /**
    * @const
    * @default "InvalidBlockId"
    */
    INVALID_BLOCK_ID: string;
    /**
    * @const
    * @default "BlobNotFound"
    */
    BLOB_NOT_FOUND: string;
    /**
    * @const
    * @default "BlobAlreadyExists"
    */
    BLOB_ALREADY_EXISTS: string;
    /**
    * @const
    * @default "ContainerAlreadyExists"
    */
    CONTAINER_ALREADY_EXISTS: string;
    /**
    * @const
    * @default "ContainerNotFound"
    */
    CONTAINER_NOT_FOUND: string;
    /**
    * @const
    * @default "InvalidBlobOrBlock"
    */
    INVALID_BLOB_OR_BLOCK: string;
    /**
    * @const
    * @default "InvalidBlockList"
    */
    INVALID_BLOCK_LIST: string;
};

export const FileErrorCodeStrings: {
    /**
    * @const
    * @default "ShareAlreadyExists"
    */
    SHARE_ALREADY_EXISTS: string;
    /**
    * @const
    * @default "ShareNotFound"
    */
    SHARE_NOT_FOUND: string;
    /**
    * @const
    * @default "FileNotFound"
    */
    FILE_NOT_FOUND: string;
};

export const QueueErrorCodeStrings: {
    /**
    * @const
    * @default "QueueNotFound"
    */
    QUEUE_NOT_FOUND: string;
    /**
    * @const
    * @default "QueueDisabled"
    */
    QUEUE_DISABLED: string;
    /**
    * @const
    * @default "QueueAlreadyExists"
    */
    QUEUE_ALREADY_EXISTS: string;
    /**
    * @const
    * @default "QueueNotEmpty"
    */
    QUEUE_NOT_EMPTY: string;
    /**
    * @const
    * @default "QueueBeingDeleted"
    */
    QUEUE_BEING_DELETED: string;
    /**
    * @const
    * @default "PopReceiptMismatch"
    */
    POP_RECEIPT_MISMATCH: string;
    /**
    * @const
    * @default "InvalidParameter"
    */
    INVALID_PARAMETER: string;
    /**
    * @const
    * @default "MessageNotFound"
    */
    MESSAGE_NOT_FOUND: string;
    /**
    * @const
    * @default "MessageTooLarge"
    */
    MESSAGE_TOO_LARGE: string;
    /**
    * @const
    * @default "InvalidMarker"
    */
    INVALID_MARKER: string;
};

/**
* Constants for storage error strings
*
* More details are at: http://msdn.microsoft.com/en-us/library/azure/dd179357.aspx
*/
export const StorageErrorCodeStrings: {
    // Not Modified (304): The condition specified in the conditional header(s) was not met for a read operation.
    // Precondition Failed (412): The condition specified in the conditional header(s) was not met for a write operation.
    /**
    * @const
    * @default "ConditionNotMet"
    */
    CONDITION_NOT_MET: string;
    // Bad Request (400): A required HTTP header was not specified.
    /**
    * @const
    * @default "MissingRequiredHeader"
    */
    MISSING_REQUIRED_HEADER: string;
    // Bad Request (400): A required XML node was not specified in the request body.
    /**
    * @const
    * @default "MissingRequiredXmlNode"
    */
    MISSING_REQUIRED_XML_NODE: string;
    // Bad Request (400): One of the HTTP headers specified in the request is not supported.
    /**
    * @const
    * @default "UnsupportedHeader"
    */
    UNSUPPORTED_HEADER: string;
    // Bad Request (400): One of the XML nodes specified in the request body is not supported.
    /**
    * @const
    * @default "UnsupportedXmlNode"
    */
    UNSUPPORTED_XML_NODE: string;
    // Bad Request (400): The value provided for one of the HTTP headers was not in the correct format.
    /**
    * @const
    * @default "InvalidHeaderValue"
    */
    INVALID_HEADER_VALUE: string;
    // Bad Request (400): The value provided for one of the XML nodes in the request body was not in the correct format.
    /**
    * @const
    * @default "InvalidXmlNodeValue"
    */
    INVALID_XML_NODE_VALUE: string;
    // Bad Request (400): A required query parameter was not specified for this request.
    /**
    * @const
    * @default "MissingRequiredQueryParameter"
    */
    MISSING_REQUIRED_QUERY_PARAMETER: string;
    // Bad Request (400): One of the query parameters specified in the request URI is not supported.
    /**
    * @const
    * @default "UnsupportedQueryParameter"
    */
    UNSUPPORTED_QUERY_PARAMETER: string;
    // Bad Request (400): An invalid value was specified for one of the query parameters in the request URI.
    /**
    * @const
    * @default "InvalidQueryParameterValue"
    */
    INVALID_QUERY_PARAMETER_VALUE: string;
    // Bad Request (400): A query parameter specified in the request URI is outside the permissible range.
    /**
    * @const
    * @default "OutOfRangeQueryParameterValue"
    */
    OUT_OF_RANGE_QUERY_PARAMETER_VALUE: string;
    // Bad Request (400): The url in the request could not be parsed.
    /**
    * @const
    * @default "RequestUrlFailedToParse"
    */
    REQUEST_URL_FAILED_TO_PARSE: string;
    // Bad Request (400): The requested URI does not represent any resource on the server.
    /**
    * @const
    * @default "InvalidUri"
    */
    INVALID_URI: string;
    // Bad Request (400): The HTTP verb specified was not recognized by the server.
    /**
    * @const
    * @default "InvalidHttpVerb"
    */
    INVALID_HTTP_VERB: string;
    // Bad Request (400): The key for one of the metadata key-value pairs is empty.
    /**
    * @const
    * @default "EmptyMetadataKey"
    */
    EMPTY_METADATA_KEY: string;
    // Bad Request (400): The specified XML is not syntactically valid.
    /**
    * @const
    * @default "InvalidXmlDocument"
    */
    INVALID_XML_DOCUMENT: string;
    // Bad Request (400): The MD5 value specified in the request did not match the MD5 value calculated by the server.
    MD5_MISMATCH: "Md5Mismatch";
    // Bad Request (400): The MD5 value specified in the request is invalid. The MD5 value must be 128 bits and Base64-encoded.
    INVALID_MD5: "InvalidMd5";
    // Bad Request (400): One of the request inputs is out of range.
    /**
    * @const
    * @default "OutOfRangeInput"
    */
    OUT_OF_RANGE_INPUT: string;
    // Bad Request (400): The authentication information was not provided in the correct format. Verify the value of Authorization header.
    /**
    * @const
    * @default "InvalidAuthenticationInfo"
    */
    INVALID_AUTHENTICATION_INFO: string;
    // Bad Request (400): One of the request inputs is not valid.
    /**
    * @const
    * @default "InvalidInput"
    */
    INVALID_INPUT: string;
    // Bad Request (400): The specified metadata is invalid. It includes characters that are not permitted.
    /**
    * @const
    * @default "InvalidMetadata"
    */
    INVALID_METADATA: string;
    // Bad Request (400): The specifed resource name contains invalid characters.
    /**
    * @const
    * @default "InvalidResourceName"
    */
    INVALID_RESOURCE_NAME: string;
    // Bad Request (400): The size of the specified metadata exceeds the maximum size permitted.
    /**
    * @const
    * @default "MetadataTooLarge"
    */
    METADATA_TOO_LARGE: string;
    // Bad Request (400): Condition headers are not supported.
    /**
    * @const
    * @default "ConditionHeadersNotSupported"
    */
    CONDITION_HEADER_NOT_SUPPORTED: string;
    // Bad Request (400): Multiple condition headers are not supported.
    /**
    * @const
    * @default "MultipleConditionHeadersNotSupported"
    */
    MULTIPLE_CONDITION_HEADER_NOT_SUPPORTED: string;
    // Forbidden (403): Server failed to authenticate the request. Make sure the value of the Authorization header is formed correctly including the signature.
    /**
    * @const
    * @default "AuthenticationFailed"
    */
    AUTHENTICATION_FAILED: string;
    // Forbidden (403): Read-access geo-redundant replication is not enabled for the account.
    // Forbidden (403): Write operations to the secondary location are not allowed.
    // Forbidden (403): The account being accessed does not have sufficient permissions to execute this operation.
    /**
    * @const
    * @default "InsufficientAccountPermissions"
    */
    INSUFFICIENT_ACCOUNT_PERMISSIONS: string;
    // Not Found (404): The specified resource does not exist.
    /**
    * @const
    * @default "ResourceNotFound"
    */
    RESOURCE_NOT_FOUND: string;
    // Forbidden (403): The specified account is disabled.
    /**
    * @const
    * @default "AccountIsDisabled"
    */
    ACCOUNT_IS_DISABLED: string;
    // Method Not Allowed (405): The resource doesn"t support the specified HTTP verb.
    /**
    * @const
    * @default "UnsupportedHttpVerb"
    */
    UNSUPPORTED_HTTP_VERB: string;
    // Conflict (409): The specified account already exists. 
    /**
    * @const
    * @default "AccountAlreadyExists"
    */
    ACCOUNT_ALREADY_EXISTS: string;
    // Conflict (409): The specified account is in the process of being created.
    /**
    * @const
    * @default "AccountBeingCreated"
    */
    ACCOUNT_BEING_CREATED: string;
    // Conflict (409): The specified resource already exists.
    /**
    * @const
    * @default "ResourceAlreadyExists"
    */
    RESOURCE_ALREADY_EXISTS: string;
    // Conflict (409): The specified resource type does not match the type of the existing resource.
    /**
    * @const
    * @default "ResourceTypeMismatch"
    */
    RESOURCE_TYPE_MISMATCH: string;
    // Length Required (411): The Content-Length header was not specified.
    /**
    * @const
    * @default "MissingContentLengthHeader"
    */
    MISSING_CONTENT_LENGTH_HEADER: string;
    // Request Entity Too Large (413): The size of the request body exceeds the maximum size permitted.
    /**
    * @const
    * @default "RequestBodyTooLarge"
    */
    REQUEST_BODY_TOO_LARGE: string;
    // Requested Range Not Satisfiable (416): The range specified is invalid for the current size of the resource.
    /**
    * @const
    * @default "InvalidRange"
    */
    INVALID_RANGE: string;
    // Internal Server Error (500): The server encountered an internal error. Please retry the request.
    /**
    * @const
    * @default "InternalError"
    */
    INTERNAL_ERROR: string;
    // Internal Server Error (500): The operation could not be completed within the permitted time.
    /**
    * @const
    * @default "OperationTimedOut"
    */
    OPERATION_TIMED_OUT: string;
    // Service Unavailable (503): The server is currently unable to receive requests. Please retry your request. 
    /**
    * @const
    * @default "ServerBusy"
    */
    SERVER_BUSY: string;

    // Legacy error code strings
    /**
    * @const
    * @default "UpdateConditionNotSatisfied"
    */
    UPDATE_CONDITION_NOT_SATISFIED: string;
    /**
    * @const
    * @default "ContainerNotFound"
    */
    CONTAINER_NOT_FOUND: string;
    /**
    * @const
    * @default "ContainerAlreadyExists"
    */
    CONTAINER_ALREADY_EXISTS: string;
    /**
    * @const
    * @default "ContainerDisabled"
    */
    CONTAINER_DISABLED: string;
    /**
    * @const
    * @default "ContainerBeingDeleted"
    */
    CONTAINER_BEING_DELETED: string;
};

export const TableErrorCodeStrings: {
    /**
    * @const
    * @default "XMethodNotUsingPost"
    */
    XMETHOD_NOT_USING_POST: string;
    /**
    * @const
    * @default "XMethodIncorrectValue"
    */
    XMETHOD_INCORRECT_VALUE: string;
    /**
    * @const
    * @default "XMethodIncorrectCount"
    */
    XMETHOD_INCORRECT_COUNT: string;
    /**
    * @const
    * @default "TableHasNoProperties"
    */
    TABLE_HAS_NO_PROPERTIES: string;
    /**
    * @const
    * @default "DuplicatePropertiesSpecified"
    */
    DUPLICATE_PROPERTIES_SPECIFIED: string;
    /**
    * @const
    * @default "TableHasNoSuchProperty"
    */
    TABLE_HAS_NO_SUCH_PROPERTY: string;
    /**
    * @const
    * @default "DuplicateKeyPropertySpecified"
    */
    DUPLICATE_KEY_PROPERTY_SPECIFIED: string;
    /**
    * @const
    * @default "TableAlreadyExists"
    */
    TABLE_ALREADY_EXISTS: string;
    /**
    * @const
    * @default "TableNotFound"
    */
    TABLE_NOT_FOUND: string;
    /**
    * @const
    * @default "EntityNotFound"
    */
    ENTITY_NOT_FOUND: string;
    /**
    * @const
    * @default "EntityAlreadyExists"
    */
    ENTITY_ALREADY_EXISTS: string;
    /**
    * @const
    * @default "PartitionKeyNotSpecified"
    */
    PARTITION_KEY_NOT_SPECIFIED: string;
    /**
    * @const
    * @default "OperatorInvalid"
    */
    OPERATOR_INVALID: string;
    /**
    * @const
    * @default "UpdateConditionNotSatisfied"
    */
    UPDATE_CONDITION_NOT_SATISFIED: string;
    /**
    * @const
    * @default "PropertiesNeedValue"
    */
    PROPERTIES_NEED_VALUE: string;
    /**
    * @const
    * @default "PartitionKeyPropertyCannotBeUpdated"
    */
    PARTITION_KEY_PROPERTY_CANNOT_BE_UPDATED: string;
    /**
    * @const
    * @default "TooManyProperties"
    */
    TOO_MANY_PROPERTIES: string;
    /**
    * @const
    * @default "EntityTooLarge"
    */
    ENTITY_TOO_LARGE: string;
    /**
    * @const
    * @default "PropertyValueTooLarge"
    */
    PROPERTY_VALUE_TOO_LARGE: string;
    /**
    * @const
    * @default "InvalidValueType"
    */
    INVALID_VALUE_TYPE: string;
    /**
    * @const
    * @default "TableBeingDeleted"
    */
    TABLE_BEING_DELETED: string;
    /**
    * @const
    * @default "TableServerOutOfMemory"
    */
    TABLE_SERVER_OUT_OF_MEMORY: string;
    /**
    * @const
    * @default "PrimaryKeyPropertyIsInvalidType"
    */
    PRIMARY_KEY_PROPERTY_IS_INVALID_TYPE: string;
    /**
    * @const
    * @default "PropertyNameTooLong"
    */
    PROPERTY_NAME_TOO_LONG: string;
    /**
    * @const
    * @default "PropertyNameInvalid"
    */
    PROPERTY_NAME_INVALID: string;
    /**
    * @const
    * @default "BatchOperationNotSupported"
    */
    BATCH_OPERATION_NOT_SUPPORTED: string;
    /**
    * @const
    * @default "JsonFormatNotSupported"
    */
    JSON_FORMAT_NOT_SUPPORTED: string;
    /**
    * @const
    * @default "MethodNotAllowed"
    */
    METHOD_NOT_ALLOWED: string;
    /**
    * @const
    * @default "NotImplemented"
    */
    NOT_IMPLEMENTED: string;
};

export const ConnectionStringKeys: {
    /**
    * @const
    * @default "UseDevelopmentStorage"
    */
    USE_DEVELOPMENT_STORAGE_NAME: string;
    /**
    * @const
    * @default "DevelopmentStorageProxyUri"
    */
    DEVELOPMENT_STORAGE_PROXY_URI_NAME: string;
    /**
    * @const
    * @default "DefaultEndpointsProtocol"
    */
    DEFAULT_ENDPOINTS_PROTOCOL_NAME: string;
    /**
    * @const
    * @default "AccountName"
    */
    ACCOUNT_NAME_NAME: string;
    /**
    * @const
    * @default "AccountKey"
    */
    ACCOUNT_KEY_NAME: string;
    /**
    * @const
    * @default "BlobEndpoint"
    */
    BLOB_ENDPOINT_NAME: string;
    /**
    * @const
    * @default "FileEndpoint"
    */
    FILE_ENDPOINT_NAME: string;
    /**
    * @const
    * @default "QueueEndpoint"
    */
    QUEUE_ENDPOINT_NAME: string;
    /**
    * @const
    * @default "TableEndpoint"
    */
    TABLE_ENDPOINT_NAME: string;
    /**
    * @const
    * @default "SharedAccessSignature"
    */
    SHARED_ACCESS_SIGNATURE_NAME: string;
    /**
    * @const
    * @default "blob.core.windows.net"
    */
    BLOB_BASE_DNS_NAME: string;
    /**
    * @const
    * @default "file.core.windows.net"
    */
    FILE_BASE_DNS_NAME: string;
    /**
    * @const
    * @default "queue.core.windows.net"
    */
    QUEUE_BASE_DNS_NAME: string;
    /**
    * @const
    * @default "table.core.windows.net"
    */
    TABLE_BASE_DNS_NAME: string;
};
}
declare module 'azure-storage/lib/common/util/constants' {
export * from '~azure-storage/lib/common/util/constants';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/util/sr.d.ts
declare module '~azure-storage/lib/common/util/sr' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

export const ANONYMOUS_ACCESS_BLOBSERVICE_ONLY: "Anonymous access is only valid for the BlobService.";
export const ARGUMENT_NULL_OR_EMPTY: "The argument must not be null or an empty string. Argument name: %s.";
export const ARGUMENT_NULL_OR_UNDEFINED: "The argument must not be null or undefined. Argument name: %s.";
export const ARGUMENT_OUT_OF_RANGE_ERROR: "The argument is out of range. Argument name: %s, Value passed: %s.";
export const BATCH_ONE_PARTITION_KEY: "All entities in the batch must have the same PartitionKey value.";
export const BATCH_ONE_RETRIEVE: "If a retrieve operation is part of a batch, it must be the only operation in the batch.";
export const BATCH_TOO_LARGE: "Batches must not contain more than 100 operations.";
export const BLOB_INVALID_SEQUENCE_NUMBER: "The sequence number may not be specified for an increment operation.";
export const BLOB_TYPE_MISMATCH: "Blob type of the blob reference doesn\"t match blob type of the blob.";
export const CANNOT_CREATE_SAS_WITHOUT_ACCOUNT_KEY: "Cannot create Shared Access Signature unless the Account Name and Key are used to create the ServiceClient.";
export const CONTENT_LENGTH_MISMATCH: "An incorrect number of bytes was read from the connection. The connection may have been closed.";
export const CONTENT_TYPE_MISSING: "Content-Type response header is missing or invalid.";
export const EMPTY_BATCH: "Batch must not be empty.";
export const EXCEEDED_SIZE_LIMITATION: "Upload exceeds the size limitation. Max size is %s but the current size is %s";
export const HASH_MISMATCH: "Hash mismatch (integrity check failed), Expected value is %s, retrieved %s.";
export const INCORRECT_ENTITY_KEYS: "PartitionKey and RowKey must be specified as strings in the entity object.";
export const INVALID_BLOB_LENGTH: "createBlockBlobFromText requires the size of text to be less than 64MB. Please use createBlockBlobFromLocalFile or createBlockBlobFromStream to upload large blobs.";
export const INVALID_CONNECTION_STRING: "Connection strings must be of the form \"key1=value1;key2=value2\".";
export const INVALID_CONNECTION_STRING_BAD_KEY: "Connection string contains unrecognized key: \"%s\"";
export const INVALID_CONNECTION_STRING_DUPLICATE_KEY: "Connection string contains duplicate key: \"%s\"";
export const INVALID_CONNECTION_STRING_EMPTY_KEY: "Connection strings must not contain empty keys.";
export const INVALID_DELETE_SNAPSHOT_OPTION: "The deleteSnapshots option cannot be included when deleting a specific snapshot using the snapshotId option.";
export const INVALID_EDM_TYPE: "The value \"%s\" does not match the type \"%s\".";
export const INVALID_FILE_LENGTH: "createFileFromText requires the size of text to be less than 4MB. Please use createFileFromLocalFile or createFileFromStream to upload large files.";
export const INVALID_FILE_RANGE_FOR_UPDATE: "Range size should be less than 4MB for a file range update operation.";
export const INVALID_HEADERS: "Headers are not supported in the 2012-02-12 version.";
export const INVALID_MESSAGE_ID: "Message ID cannot be null or undefined for deleteMessage and updateMessage operations.";
export const INVALID_PAGE_BLOB_LENGTH: "Page blob length must be multiple of 512.";
export const INVALID_PAGE_END_OFFSET: "Page end offset must be multiple of 512.";
export const INVALID_PAGE_RANGE_FOR_UPDATE: "Page range size should be less than 4MB for a page update operation.";
export const INVALID_PAGE_START_OFFSET: "Page start offset must be multiple of 512.";
export const INVALID_POP_RECEIPT: "Pop Receipt cannot be null or undefined for deleteMessage and updateMessage operations.";
export const INVALID_PROPERTY_RESOLVER: "The specified property resolver returned an invalid type. %s:{_:%s,$:%s }";
export const INVALID_RANGE_FOR_MD5: "The requested range should be less than 4MB when contentMD5 is expected from the server";
export const INVALID_SAS_VERSION: "SAS Version ? is invalid. Valid versions include: ?.";
export const INVALID_SAS_TOKEN: "The SAS token should not contain api-version.";
export const INVALID_SIGNED_IDENTIFIERS: "Signed identifiers need to be a hash object with key as the id and the value as the access policy.";
export const INVALID_STREAM_LENGTH: "The length of the provided stream is invalid.";
export const INVALID_STRING_ERROR: "Invalid string error.";
export const INVALID_TABLE_OPERATION: "Operation not found: %s";
export const INVALID_TEXT_LENGTH: "The length of the provided text is invalid.";
export const MAXIMUM_EXECUTION_TIMEOUT_EXCEPTION: "The client could not finish the operation within specified maximum execution timeout.";
export const MD5_NOT_POSSIBLE: "MD5 cannot be calculated for an existing blob because it would require reading the existing data. Please disable storeBlobContentMD5.";
export const MD5_NOT_PRESENT_ERROR: "MD5 does not exist. If you do not want to force validation, please disable useTransactionalMD5.";
export const METADATA_KEY_INVALID: "The key for one of the metadata key-value pairs is null, empty, or whitespace.";
export const METADATA_VALUE_INVALID: "The value for one of the metadata key-value pairs is null, empty, or whitespace.";
export const NO_CREDENTIALS_PROVIDED: "Credentials must be provided when creating a service client.";
export const PRIMARY_ONLY_COMMAND: "This operation can only be executed against the primary storage location.";
export const QUERY_OPERATOR_REQUIRES_WHERE: "%s operator needs to be used after where.";
export const SECONDARY_ONLY_COMMAND: "This operation can only be executed against the secondary storage location.";
export const STORAGE_HOST_LOCATION_REQUIRED: "The host for the storage service must be specified.";
export const STORAGE_HOST_MISSING_LOCATION: "The host for the target storage location is not specified. Please consider changing the request\"s location mode.";
export const TYPE_NOT_SUPPORTED: "Type not supported when sending data to the service: ";
export const MAX_BLOB_SIZE_CONDITION_NOT_MEET: "Append block data should not exceed the maximum blob size condition value.";
}
declare module 'azure-storage/lib/common/util/sr' {
export * from '~azure-storage/lib/common/util/sr';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/util/date.d.ts
declare module '~azure-storage/lib/common/util/date' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

export type date = string | number | Date;
}
declare module 'azure-storage/lib/common/util/date' {
export * from '~azure-storage/lib/common/util/date';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/util/validate.d.ts
declare module '~azure-storage/lib/common/util/validate' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

export {};
}
declare module 'azure-storage/lib/common/util/validate' {
export * from '~azure-storage/lib/common/util/validate';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/util/storageutilities.d.ts
declare module '~azure-storage/lib/common/util/storageutilities' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* Defines constants, enums, and utility functions for use with storage.
* @namespace
*/

/**
* Specifies the location mode used to decide which location the request should be sent to.
*
* @const
* @enum {number}
*/
export const LocationMode: {
  /** The primary location only */
  PRIMARY_ONLY: number;

  /** The primary location first, then the secondary */
  PRIMARY_THEN_SECONDARY: number;

  /** The secondary location only */
  SECONDARY_ONLY: number;

  /** The secondary location first, then the primary */
  SECONDARY_THEN_PRIMARY: number;
};
}
declare module 'azure-storage/lib/common/util/storageutilities' {
export * from '~azure-storage/lib/common/util/storageutilities';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/util/accesscondition.d.ts
declare module '~azure-storage/lib/common/util/accesscondition' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* Defines constants, enums, and utility functions for use with storage access condition.
* @namespace
*/

export interface AccessConditions {
  EtagNonMatch?: string;
  EtagMatch?: string;
  DateModifedSince?: Date | string;
  DateUnModifedSince?: Date | string;
  SequenceNumberEqual?: number | string;
  SequenceNumberLessThan?: number | string;
  SequenceNumberLessThanOrEqual?: number | string;
}

export type EmptyCondition = {} & AccessConditions;
export type IfNotExistsCondition = { EtagNonMatch: "*" } & AccessConditions;
export type IfExistsCondition = { EtagMatch: "*" } & AccessConditions;
export type IfNoneMatchCondition = { EtagNonMatch: string } & AccessConditions;
export type IfMatchCondition = { EtagMatch: string } & AccessConditions;
export type IfModifiedSinceCondition = { DateModifedSince: Date | string } & AccessConditions;
export type IfNotModifiedSinceCondition = { DateUnModifedSince: Date | string } & AccessConditions;
export type SequenceNumberEqualCondition = { SequenceNumberEqual: number | string } & AccessConditions;
export type SequenceNumberLessThanCondition = { SequenceNumberLessThan: number | string } & AccessConditions;
export type SequenceNumberLessThanOrEqualCondition = { SequenceNumberLessThanOrEqual: number | string } & AccessConditions;

/**
* Constructs an empty access condition.
* @return {AccessCondition} An empty AccessCondition object
*/
export function generateEmptyCondition(): EmptyCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource does not exist on the service
* Setting this access condition modifies the request to include the HTTP If-None-Match conditional header

* @return {AccessConditions} An AccessCondition object that represents a condition that checks for nonexistence
*/
export function generateIfNotExistsCondition(): IfNotExistsCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource exists on the service
* Setting this access condition modifies the request to include the HTTP If-Match conditional header

* @return {AccessConditions} An AccessCondition object that represents a condition that checks for existence
*/
export function generateIfExistsCondition(): IfExistsCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource's ETag value 
* does not match the specified ETag value.
* Setting this access condition modifies the request to include the HTTP If-None-Match conditional header
*
* @param  {string} etag                    The ETag value to check against the resource's ETag
* @return {AccessConditions}               An AccessCondition object that represents the If-None-Match condition
*/
export function generateIfNoneMatchCondition(etag: string): IfNoneMatchCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource's ETag value
* matches the specified ETag value
* Setting this access condition modifies the request to include the HTTP If-Match conditional header
*
* @param  {string} etag                    The ETag value to check against the resource's ETag
* @return {AccessConditions}               An AccessCondition object that represents the If-Match condition
*/
export function generateIfMatchCondition(etag: string): IfMatchCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource has been
* modified since the specified time
*
* Setting this access condition modifies the request to include the HTTP If-Modified-Since conditional header
*
* @param  {Date|string}  time              A date object specifying the time since which the resource must have been modified
* @return {AccessConditions}               An AccessCondition object that represents the If-Modified-Since condition
*/
export function generateIfModifiedSinceCondition(time: Date | string): IfModifiedSinceCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource has not been
* modified since the specified time
* Setting this access condition modifies the request to include the HTTP If-Unmodified-Since conditional header
*
* @param  {Date|string}    time            A date object specifying the time since which the resource must have not been modified
* @return {AccessConditions}               An AccessCondition object that represents the If-Unmodified-Since condition
*/
export function generateIfNotModifiedSinceCondition(time: Date | string): IfNotModifiedSinceCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource's sequence number
* is equal to the specified value
* Setting this access condition modifies the request to include the HTTP x-ms-if-sequence-number-eq conditional header
*
* @param  {Number|string}    sequenceNumber    A date object specifying the time since which the resource must have not been modified
* @return {AccessConditions}                   An AccessCondition object that represents the If-Unmodified-Since condition
*/
export function generateSequenceNumberEqualCondition(sequenceNumber: number | string): SequenceNumberEqualCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource's sequence number
* is less than the specified value
* Setting this access condition modifies the request to include the HTTP x-ms-if-sequence-number-lt conditional header
*
* @param  {Number|string}    sequenceNumber    A date object specifying the time since which the resource must have not been modified
* @return {AccessConditions}                   An AccessCondition object that represents the If-Unmodified-Since condition
*/
export function generateSequenceNumberLessThanCondition(sequenceNumber: number | string): SequenceNumberLessThanCondition;

/**
* Constructs an access condition such that an operation will be performed only if the resource's sequence number
* is less than or equal to the specified value
* Setting this access condition modifies the request to include the HTTP x-ms-if-sequence-number-le conditional header
*
* @param  {Number|string}    sequenceNumber    A date object specifying the time since which the resource must have not been modified
* @return {AccessConditions}                   An AccessCondition object that represents the If-Unmodified-Since condition
*/
export function generateSequenceNumberLessThanOrEqualCondition(sequenceNumber: number | string): SequenceNumberLessThanOrEqualCondition;
}
declare module 'azure-storage/lib/common/util/accesscondition' {
export * from '~azure-storage/lib/common/util/accesscondition';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/common.d.ts
declare module '~azure-storage/lib/common/common' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

export import Logger = require('~azure-storage/lib/common/diagnostics/logger');
export import WebResource = require('~azure-storage/lib/common/http/webresource');

export import StorageServiceClient = require('~azure-storage/lib/common/services/storageserviceclient');

export import LinearRetryPolicyFilter = require('~azure-storage/lib/common/filters/linearretrypolicyfilter');
export import ExponentialRetryPolicyFilter = require('~azure-storage/lib/common/filters/exponentialretrypolicyfilter');
export import RetryPolicyFilter = require('~azure-storage/lib/common/filters/retrypolicyfilter');

export import SpeedSummary = require('~azure-storage/lib/common/streams/speedsummary');

export import Constants = require('~azure-storage/lib/common/util/constants');
export import SR = require('~azure-storage/lib/common/util/sr');
export import date = require('~azure-storage/lib/common/util/date');
export import validate = require('~azure-storage/lib/common/util/validate');
export import StorageUtilities = require('~azure-storage/lib/common/util/storageutilities');
export import AccessCondition = require('~azure-storage/lib/common/util/accesscondition');
}
declare module 'azure-storage/lib/common/common' {
export * from '~azure-storage/lib/common/common';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/common/errors/errors.d.ts
declare module '~azure-storage/lib/common/errors/errors' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

export class ArgumentError extends Error {
    argumentName: string;
    
    constructor(argumentName: string, message: string);
}

export class ArgumentNullError extends Error {
    argumentName: string;
    
    constructor(argumentName: string, message: string);
}

export class StorageError extends Error {
    [key: string]: any;
    
    code: string;
    statusCode: number;
    requestId: string;
    path: string;
    
    constructor(message: string, properties: Object);
}

export class TimeoutError extends Error {
    constructor(message: string);
}
}
declare module 'azure-storage/lib/common/errors/errors' {
export * from '~azure-storage/lib/common/errors/errors';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/table/tableservice.d.ts
declare module '~azure-storage/lib/services/table/tableservice' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

import { StorageServiceClient } from '~azure-storage/lib/common/common';
import { StorageError } from '~azure-storage/lib/common/errors/errors';
import * as TableQuery from '~azure-storage/lib/services/table/tablequery';
import * as TableBatch from '~azure-storage/lib/services/table/tablebatch';

type ErrorOrResult<T> = StorageServiceClient.ErrorOrResult<T>;
type ErrorOrList<T> = StorageServiceClient.ErrorOrList<T>;

/**
* @class
* @extends {StorageServiceClient}
* The TableService object allows you to peform management operations with the Microsoft Azure Table Service.
* The Table Service stores data in rows of key-value pairs. A table is composed of multiple rows, and each row
* contains key-value pairs. There is no schema, so each row in a table may store a different set of keys.
*
* For more information on the Table Service, as well as task focused information on using it from a Node.js application, see
* [How to Use the Table Service from Node.js](http://azure.microsoft.com/en-us/documentation/articles/storage-nodejs-how-to-use-table-storage/).
*/
class TableService extends StorageServiceClient {
    /** The default timeout interval, in milliseconds, to use for request made via the Table service. */
    defaultTimeoutIntervalInMs: number;
    /** The default maximum execution time across all potential retries, for requests made via the Table service. */
    defaultMaximumExecutionTimeInMs: number;
    /** The default location mode for requests made via the Table service. */
    defaultLocationMode: number;
    /** The default payload format for requests made via the Table service. */
    defaultPayloadFormat: number;
    /**
     * Determines whether the Nagle algorithm is used for requests made via the Table service; true to use the Nagle algorithm; otherwise, false. 
     * The default value is false.
     */
    useNagleAlgorithm: boolean;
    
    
    /**
    * Creates a new TableService object using the AZURE_STORAGE_CONNECTION_STRING or AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY environment variables.
    * @constructor
    */
    constructor();
    /**
    * Creates a new TableService object using the given connection string.
    *
    * @constructor
    * @param {string} connectionString                    The storage account or the connection string.
    */    
    constructor(connectionString: string);
    /**
    * Creates a new TableService object using the given parameters.
    *
    * @constructor
    * @param {string} [storageAccount]                    The storage account.
    * @param {string} [storageAccessKey]                  The storage access key.
    * @param {string|object} [host]                       The host address. To define primary only, pass a string. 
    *                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
    * @param {string} [sasToken]                          The Shared Access Signature token.
    */
    constructor(storageAccount: string, storageAccessKey: string, host?: StorageServiceClient.HostConfiguration, sasToken?: string);
    
    
    // ***********************************************************
    // ** SERVICE METHODS
    // ***********************************************************
        
    /**
    * Gets the service stats for a storage account’s Table service.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ServiceStats}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getServiceStats(callback: ErrorOrResult<StorageServiceClient.ServiceStats>): void;
    /**
    * Gets the service stats for a storage account’s Table service.
    * @param {object}         options                               The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ServiceStats}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getServiceStats(options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<StorageServiceClient.ServiceStats>): void;
    
    
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getServiceProperties(callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {object}       options                                 The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getServiceProperties(options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    
    
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {ServiceOptions}     options                                  The request options.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    
    // ***********************************************************
    // ** TABLE LIST METHODS
    // ***********************************************************
    
    /**
    * Lists a segment containing a collection of table items under the specified account.
    *
    * @param {object}             currentToken                                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                                          `error` will contain information if an error occurs; 
    *                                                                               otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                               `entries`  gives a list of tables and the `continuationToken` is used for the next listing operation.
    *                                                                               `response` will contain information related to this operation.
    */
    listTablesSegmented(currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrResult<TableService.TableListResult>): void;
    /**
    * Lists a segment containing a collection of table items under the specified account.
    *
    * @param {object}             currentToken                                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                           The create options or callback function.
    * @param {errorOrResult}      callback                                          `error` will contain information if an error occurs; 
    *                                                                               otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                               `entries`  gives a list of tables and the `continuationToken` is used for the next listing operation.
    *                                                                               `response` will contain information related to this operation.
    */
    listTablesSegmented(currentToken: StorageServiceClient.ContinuationToken, options: TableService.ListTableOptions, callback: ErrorOrResult<TableService.TableListResult>): void;
    
    /**
    * Lists a segment containing a collection of table items under the specified account.
    *
    * @param {string}             prefix                                            The prefix of the table name.
    * @param {object}             currentToken                                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                                          `error` will contain information if an error occurs; 
    *                                                                               otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                               `entries`  gives a list of tables and the `continuationToken` is used for the next listing operation.
    *                                                                               `response` will contain information related to this operation.
    */
    listTablesSegmentedWithPrefix(prefix: string, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrResult<TableService.TableListResult>): void;
    /**
    * Lists a segment containing a collection of table items under the specified account.
    *
    * @param {string}             prefix                                            The prefix of the table name.
    * @param {object}             currentToken                                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                           The create options or callback function.
    * @param {errorOrResult}      callback                                          `error` will contain information if an error occurs; 
    *                                                                               otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                               `entries`  gives a list of tables and the `continuationToken` is used for the next listing operation.
    *                                                                               `response` will contain information related to this operation.
    */
    listTablesSegmentedWithPrefix(prefix: string, currentToken: StorageServiceClient.ContinuationToken, options: TableService.ListTableOptions, callback: ErrorOrResult<TableService.TableListResult>): void;
    
    
    // ***********************************************************
    // ** TABLE METHODS
    // ***********************************************************
    
    /**
    * Gets the queue's ACL.
    *
    * @param {string}             table                                       The table name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link TableResult}` will contain
    *                                                                         information for the table.
    *                                                                         `response` will contain information related to this operation.
    */
    getTableAcl(table: string, callback: ErrorOrResult<TableService.TableResult>): void;
    /**
    * Gets the table's ACL.
    *
    * @param {string}             table                                       The table name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link TableResult}` will contain
    *                                                                         information for the table.
    *                                                                         `response` will contain information related to this operation.
    */
    getTableAcl(table: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<TableService.TableResult>): void;
    
    /**
    * Updates the table's ACL.
    *
    * @param {string}             table                                       The table name.
    * @param {Object.<string, AccessPolicy>} signedIdentifiers                The container ACL settings. See `[AccessPolicy]{@link AccessPolicy}` for detailed information.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link TableResult}` will contain
    *                                                                         information for the table.
    *                                                                         `response` will contain information related to this operation.
    */
    setTableAcl(table: string, signedIdentifiers: StorageServiceClient.SignedIdentifiers, callback: ErrorOrResult<TableService.TableResult>): void;
    /**
    * Updates the table's ACL.
    *
    * @param {string}             table                                       The table name.
    * @param {Object.<string, AccessPolicy>} signedIdentifiers                The container ACL settings. See `[AccessPolicy]{@link AccessPolicy}` for detailed information.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link TableResult}` will contain
    *                                                                         information for the table.
    *                                                                         `response` will contain information related to this operation.
    */
    setTableAcl(table: string, signedIdentifiers: StorageServiceClient.SignedIdentifiers, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<TableService.TableResult>): void;
    
    /**
    * Retrieves a shared access signature token.
    *
    * @param {string}                   table                                               The table name.
    * @param {object}                   sharedAccessPolicy                                  The shared access policy.
    * @return {string}
    */
    generateSharedAccessSignature(table: string, sharedAccessPolicy: TableService.SharedAccessPolicy): string;
    
    /**
    * Checks whether or not a table exists on the service.
    *
    * @param {string}             table                                   The table name.
    * @param {errorOrResult}      callback                                `error` will contain information if an error occurs; 
    *                                                                     otherwise `result` will contain the table information including `exists` boolean member. 
    *                                                                     `response` will contain information related to this operation.
    */
    doesTableExist(table: string, callback: ErrorOrResult<TableService.TableResult>): void;
    /**
    * Checks whether or not a table exists on the service.
    *
    * @param {string}             table                                   The table name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information if an error occurs; 
    *                                                                     otherwise `result` will contain the table information including `exists` boolean member. 
    *                                                                     `response` will contain information related to this operation.
    */
    doesTableExist(table: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<TableService.TableResult>): void;
    
    /**
    * Creates a new table within a storage account.
    *
    * @param {string}             table                                   The table name.
    * @param {errorOrResult}      callback                                `error` will contain information if an error occurs; 
    *                                                                     otherwise `result` will contain the new table information.
    *                                                                     `response` will contain information related to this operation.
    */
    createTable(table: string, callback: ErrorOrResult<TableService.TableResult>): void;
    /**
    * Creates a new table within a storage account.
    *
    * @param {string}             table                                   The table name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information if an error occurs; 
    *                                                                     otherwise `result` will contain the new table information.
    *                                                                     `response` will contain information related to this operation.
    */
    createTable(table: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<TableService.TableResult>): void;
    
    /**
    * Creates a new table within a storage account if it does not exists.
    *
    * @param {string}             table                                   The table name.
    * @param {errorOrResult}      callback                                `error` will contain information if an error occurs; 
    *                                                                     otherwise `result` will contain the new table information.
    *                                                                     `response` will contain information related to this operation.
    */
    createTableIfNotExists(table: string, callback: ErrorOrResult<TableService.TableResult>): void;
    /**
    * Creates a new table within a storage account if it does not exists.
    *
    * @param {string}             table                                   The table name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information if an error occurs; 
    *                                                                     otherwise `result` will contain the new table information.
    *                                                                     `response` will contain information related to this operation.
    */
    createTableIfNotExists(table: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<TableService.TableResult>): void;
    
    /**
    * Deletes a table from a storage account.
    *
    * @param {string}             table                                   The table name.
    * @param {errorOrResponse}    callback                                `error` will contain information if an error occurs;
    *                                                                     `response` will contain information related to this operation.
    */
    deleteTable(table: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Deletes a table from a storage account.
    *
    * @param {string}             table                                   The table name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResponse}    callback                                `error` will contain information if an error occurs;
    *                                                                     `response` will contain information related to this operation.
    */
    deleteTable(table: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Deletes a table from a storage account, if it exists.
    *
    * @param {string}             table                                   The table name.
    * @param {errorOrResponse}    callback                                `error` will contain information if an error occurs; 
    *                                                                     `result` will be `true` if table was deleted, false otherwise
    *                                                                     `response` will contain information related to this operation.
    */
    deleteTableIfExists(table: string, callback: ErrorOrResult<boolean>): void;
    /**
    * Deletes a table from a storage account, if it exists.
    *
    * @param {string}             table                                   The table name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResponse}    callback                                `error` will contain information if an error occurs; 
    *                                                                     `result` will be `true` if table was deleted, false otherwise
    *                                                                     `response` will contain information related to this operation.
    */
    deleteTableIfExists(table: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<boolean>): void;
    
    
    // ***********************************************************
    // ** TABLE ENTITY METHODS
    // ***********************************************************
    
    /**
    * Queries data in a table. To retrieve a single entity by partition key and row key, use retrieve entity.
    *
    * @param {string}             table                                                The table name.
    * @param {TableQuery}         tableQuery                                           The query to perform. Use null, undefined, or new TableQuery() to get all of the entities in the table.
    * @param {object}             currentToken                                         A continuation token returned by a previous listing operation. 
    *                                                                                  Please use 'null' or 'undefined' if this is the first operation.
    * @param {QueryResponse}      callback                                             `error` will contain information if an error occurs; 
    *                                                                                  otherwise `entities` will contain the entities returned by the query. 
    *                                                                                  If more matching entities exist, and could not be returned,
    *                                                                                  `queryResultContinuation` will contain a continuation token that can be used
    *                                                                                  to retrieve the next set of results.
    *                                                                                  `response` will contain information related to this operation.
    */
    queryEntities(table: string, tableQuery: TableQuery, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrResult<TableService.TableQueryResult<TableService.TableEntity>>): void;
    /**
    * Queries data in a table. To retrieve a single entity by partition key and row key, use retrieve entity.
    *
    * @param {string}             table                                                The table name.
    * @param {TableQuery}         tableQuery                                           The query to perform. Use null, undefined, or new TableQuery() to get all of the entities in the table.
    * @param {object}             currentToken                                         A continuation token returned by a previous listing operation. 
    *                                                                                  Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                              The request options.
    * @param {QueryResponse}      callback                                             `error` will contain information if an error occurs; 
    *                                                                                  otherwise `entities` will contain the entities returned by the query. 
    *                                                                                  If more matching entities exist, and could not be returned,
    *                                                                                  `queryResultContinuation` will contain a continuation token that can be used
    *                                                                                  to retrieve the next set of results.
    *                                                                                  `response` will contain information related to this operation.
    */
    queryEntities(table: string, tableQuery: TableQuery, currentToken: StorageServiceClient.ContinuationToken, options: TableService.GetEntityOptions, callback: ErrorOrResult<TableService.TableQueryResult<TableService.TableEntity>>): void;
    /**
    * Queries data in a table. To retrieve a single entity by partition key and row key, use retrieve entity.
    *
    * @param {string}             table                                                The table name.
    * @param {TableQuery}         tableQuery                                           The query to perform. Use null, undefined, or new TableQuery() to get all of the entities in the table.
    * @param {object}             currentToken                                         A continuation token returned by a previous listing operation. 
    *                                                                                  Please use 'null' or 'undefined' if this is the first operation.
    * @param {QueryResponse}      callback                                             `error` will contain information if an error occurs; 
    *                                                                                  otherwise `entities` will contain the entities returned by the query. 
    *                                                                                  If more matching entities exist, and could not be returned,
    *                                                                                  `queryResultContinuation` will contain a continuation token that can be used
    *                                                                                  to retrieve the next set of results.
    *                                                                                  `response` will contain information related to this operation.
    */
    queryEntities<T extends TableService.TableEntity>(table: string, tableQuery: TableQuery, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrResult<TableService.TableQueryResult<T>>): void;
    /**
    * Queries data in a table. To retrieve a single entity by partition key and row key, use retrieve entity.
    *
    * @param {string}             table                                                The table name.
    * @param {TableQuery}         tableQuery                                           The query to perform. Use null, undefined, or new TableQuery() to get all of the entities in the table.
    * @param {object}             currentToken                                         A continuation token returned by a previous listing operation. 
    *                                                                                  Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                              The request options.
    * @param {QueryResponse}      callback                                             `error` will contain information if an error occurs; 
    *                                                                                  otherwise `entities` will contain the entities returned by the query. 
    *                                                                                  If more matching entities exist, and could not be returned,
    *                                                                                  `queryResultContinuation` will contain a continuation token that can be used
    *                                                                                  to retrieve the next set of results.
    *                                                                                  `response` will contain information related to this operation.
    */
    queryEntities<T extends TableService.TableEntity>(table: string, tableQuery: TableQuery, currentToken: StorageServiceClient.ContinuationToken, options: TableService.GetEntityOptions, callback: ErrorOrResult<TableService.TableQueryResult<T>>): void;
    
    /**
    * Retrieves an entity from a table.
    *
    * @param {string}             table                                           The table name.
    * @param {string}             partitionKey                                    The partition key.
    * @param {string}             rowKey                                          The row key.
    * @param {errorOrResult}  callback                                            `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will be the matching entity.
    *                                                                             `response` will contain information related to this operation.
    */
    retrieveEntity(table: string, partitionKey: string, rowKey: string, callback: ErrorOrResult<TableService.TableEntity>): void;
    /**
    * Retrieves an entity from a table.
    *
    * @param {string}             table                                           The table name.
    * @param {string}             partitionKey                                    The partition key.
    * @param {string}             rowKey                                          The row key.
    * @param {object}             options                                         The request options.
    * @param {errorOrResult}  callback                                            `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will be the matching entity.
    *                                                                             `response` will contain information related to this operation.
    */
    retrieveEntity(table: string, partitionKey: string, rowKey: string, options: TableService.GetEntityOptions, callback: ErrorOrResult<TableService.TableEntity>): void;
    
    /**
    * Retrieves an entity from a table.
    *
    * @param {string}             table                                           The table name.
    * @param {string}             partitionKey                                    The partition key.
    * @param {string}             rowKey                                          The row key.
    * @param {errorOrResult}  callback                                            `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will be the matching entity.
    *                                                                             `response` will contain information related to this operation.
    */
    retrieveEntity<T extends TableService.TableEntity>(table: string, partitionKey: string, rowKey: string, callback: ErrorOrResult<T>): void;
    /**
    * Retrieves an entity from a table.
    *
    * @param {string}             table                                           The table name.
    * @param {string}             partitionKey                                    The partition key.
    * @param {string}             rowKey                                          The row key.
    * @param {object}             options                                         The request options.
    * @param {errorOrResult}  callback                                            `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will be the matching entity.
    *                                                                             `response` will contain information related to this operation.
    */
    retrieveEntity<T extends TableService.TableEntity>(table: string, partitionKey: string, rowKey: string, options: TableService.GetEntityOptions, callback: ErrorOrResult<T>): void;
    
    /**
    * Inserts a new entity into a table.
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    insertEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, callback: ErrorOrResult<T>): void;
    /**
    * Inserts a new entity into a table.
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {object}             options                                         The request options.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    insertEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, options: TableService.InsertEntityOptions, callback: ErrorOrResult<T>): void;
    
    /**
    * Inserts or updates a new entity into a table.
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    insertOrReplaceEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, callback: ErrorOrResult<T>): void;
    /**
    * Inserts or updates a new entity into a table.
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {object}             options                                         The request options.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    insertOrReplaceEntity<T extends TableService.TableEntity>(table: string, entityDescriptor:T, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<T>): void;
    
    /**
    * Replaces an existing entity within a table. To replace conditionally based on etag, set entity['.metadata']['etag'].
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    replaceEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, callback: ErrorOrResult<T>): void;
    /**
    * Replaces an existing entity within a table. To replace conditionally based on etag, set entity['.metadata']['etag'].
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {object}             options                                         The request options.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    replaceEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<T>): void;
    
    /**
    * Updates an existing entity within a table by merging new property values into the entity. To merge conditionally based on etag, set entity['.metadata']['etag'].
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    mergeEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, callback: ErrorOrResult<T>): void;
    /**
    * Updates an existing entity within a table by merging new property values into the entity. To merge conditionally based on etag, set entity['.metadata']['etag'].
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {object}             options                                         The request options.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    mergeEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<T>): void;
    
    /**
    * Inserts or updates an existing entity within a table by merging new property values into the entity.
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    insertOrMergeEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, callback: ErrorOrResult<T>): void;
    /**
    * Inserts or updates an existing entity within a table by merging new property values into the entity.
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {object}             options                                         The request options.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    insertOrMergeEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<T>): void;
    
    /**
    * Deletes an entity within a table. To delete conditionally based on etag, set entity['.metadata']['etag'].
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    deleteEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Deletes an entity within a table. To delete conditionally based on etag, set entity['.metadata']['etag'].
    *
    * @param {string}             table                                           The table name.
    * @param {object}             entityDescriptor                                The entity descriptor.
    * @param {object}             options                                         The request options.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain the entity information.
    *                                                                             `response` will contain information related to this operation.
    */
    deleteEntity<T extends TableService.TableEntity>(table: string, entityDescriptor: T, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Executes the operations in the batch.
    *
    * @param {string}             table                                           The table name.
    * @param {TableBatch}         batch                                           The table batch to execute.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain responses for each operation executed in the batch;
    *                                                                             `result.entity` will contain the entity information for each operation executed.
    *                                                                             `result.response` will contain the response for each operations executed.
    *                                                                             `response` will contain information related to this operation.
    */
    executeBatch(table: string, batch: TableBatch, callback: ErrorOrResult<TableService.BatchResult[]>): void;
    /**
    * Executes the operations in the batch.
    *
    * @param {string}             table                                           The table name.
    * @param {TableBatch}         batch                                           The table batch to execute.
    * @param {object}             options                                         The create options or callback function.
    * @param {errorOrResult}      callback                                        `error` will contain information if an error occurs; 
    *                                                                             otherwise `result` will contain responses for each operation executed in the batch;
    *                                                                             `result.entity` will contain the entity information for each operation executed.
    *                                                                             `result.response` will contain the response for each operations executed.
    *                                                                             `response` will contain information related to this operation.
    */
    executeBatch(table: string, batch: TableBatch, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<TableService.BatchResult[]>): void;
}

namespace TableService {
    
    export type QueryResponse<T extends TableService.TableEntity> = ErrorOrResult<TableQueryResult<T>>;
    
    // ***********************************************************
    // ** RESULTS
    // ***********************************************************
    
    export interface TableResult {
        /** The table name. */
        name: string;
        /** The table name. */
        TableName?: string;
        /** The table ACL settings. See AccessPolicy for detailed information. */
        signedIdentifiers?: StorageServiceClient.SignedIdentifiersResult;
        /** Does the table exists? Available after a doesTableExists call. */
        exists?: boolean;
        /** Was the table created? Available after a createTableIfNotExists call. */
        created?: boolean;
    }
    
    export interface TableListResult {
        entries: TableResult[];
        continuationToken: TableContinuationToken;
    }
    
    export interface TableQueryResult<T extends TableService.TableEntity> {
        entries: T[];
        continuationToken: EntityContinuationToken;
    }
    
    export interface BatchResult {
        entity: TableEntity;
        response: StorageServiceClient.ServiceResponse;
    }
    
    export interface TableEntity {
        PartitionKey: EntityProperty<string>;
        RowKey: EntityProperty<string>;
        Timestamp?: EntityProperty<Date>;
        Etag?: EntityProperty<string>;
    }
    
    export interface EntityProperty<T> {
        _: T;
        $?: string;
    }
    
    export interface SharedAccessPolicy {
        Id?: string;
        AccessPolicy?: AccessPolicy;
    }
    
    export interface AccessPolicy extends StorageServiceClient.AccessPolicy {
        /** The starting Partition Key for which the SAS will be valid. */
        StartPk?: string;
        /** The ending Partition Key for which the SAS will be valid. */
        EndPk?: string;
        /** The starting Row Key for which the SAS will be valid. */
        StartRk?: string;
        /** The ending Row Key for which the SAS will be valid. */
        EndRk?: string;
    }
    
    export interface TableContinuationToken {
        nextTableName: string;
        targetLocation: string;
    }
    
    export interface EntityContinuationToken {
        nextPartitionKey: string;
        nextRowKey: string;
        targetLocation: string;
    }
    
    /**
     * Given the partition key, row key, property name, property value, and the property Edm type if given by the service, returns the Edm type of the property.
     * @param {object}  pk          The partition key.
     * @param {object}  rk          The row key.
     * @param {string}  name        The property name.
     * @param {object}  value       The property value.
     * @param {string}  type        The EDM type.
     */
    export type PropertyResolver = (pk: EntityProperty<string>, rk: EntityProperty<string>, name: string, value: any, type?: string) => string;
        
    /**
     * The entity resolver. Given the single entity, returns a modified object.
     * @param {object}  entity      The entity to resolve.
     */
    export type EntityResolver = (entity: any) => any;
    
    // ***********************************************************
    // ** OPTIONS
    // ***********************************************************
    
    export interface ListTableOptions extends StorageServiceClient.ServiceClientOptions {
        /** Specifies the maximum number of tables to return per call to Azure ServiceClient. */
        maxResults?: number;
    }
    
    export interface GetEntityOptions extends StorageServiceClient.ServiceClientOptions {
        /** The payload format to use for the request. */
        payloadFormat?: string;
        /** If true, guess at all property types. */
        autoResolveProperties?: boolean;
        /** The entity resolver. Given a single entity returned by the query, returns a modified object which is added to the entities array. */
        entityResolver?: EntityResolver;
        /** The property resolver. Given the partition key, row key, property name, property value, and the property Edm type if given by the service, returns the Edm type of the property. */
        propertyResolver?: PropertyResolver;
    }
    
    export interface InsertEntityOptions extends GetEntityOptions {
        /** Whether or not to return the entity upon a successful insert. Inserts only, default to false. */
        echoContent?: boolean;
    }
}

export = TableService;
}
declare module 'azure-storage/lib/services/table/tableservice' {
import main = require('~azure-storage/lib/services/table/tableservice');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/table/tablebatch.d.ts
declare module '~azure-storage/lib/services/table/tablebatch' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

class TableBatch {
    operations: TableBatch.Operation[];
    pk: string;
    retrieve: boolean;
    
    /**
    * @constructor
    * Creates a new TableBatch.
    */
    constructor();
    
    // ***********************************************************
    // ** BATCH
    // ***********************************************************
    
    /**
    * Removes all of the operations from the batch.
    */
    clear(): void;
    
    /**
    * Returns a boolean value indicating weather there are operations in the batch.
    * @return {Boolean} True if there are operations queued up; false otherwise.
    */
    hasOperations(): boolean;
    
    /**
    * Returns the number of operations in the batch.
    * @return {number} The number of operations in the batch.
    */
    size(): number;
    
    /**
    * Adds an operation to the batch after performing checks.
    * @param {string}             operationType       The type of operation to perform. See Constants.TableConstants.Operations
    * @param {object}             entity              The entity.
    * @param {object}             [options]           The request options.
    */
    addOperation(operationType: string, entity: any, options?: Object): void;
    
    /**
    * Adds an operation to the batch after performing checks.
    * @param {number}             index           The index of the operation in the operations array.
    * @return {object}                            The found operation.
    */
    getOperation(index: number): TableBatch.Operation;
    
    /**
    * Adds an operation to the batch after performing checks.
    * @param {number}             index           The index in the operations array at which to remove an element.
    * @return {object}                            The removed operation.
    */
    removeOperation(index: number): TableBatch.Operation;
    
    
    // ***********************************************************
    // ** OPERATIONS
    // ***********************************************************
    
    /**
    * Adds a retrieve operation to the batch. Note that this must be the only operation in the batch.
    * @param {string}             partitionKey        The partition key.
    * @param {string}             rowKey              The row key.
    * @param {object}             [options]           The request options.
    */
    retrieveEntity(partitionKey: string, rowKey: string, options?: TableBatch.RetrieveOptions): void;
    
    /**
    * Adds an insert operation to the batch.
    * @param {object}             entity              The entity.
    * @param {object}             [options]           The request options.
    */
    insertEntity(entity: any, options?: TableBatch.InsertOptions): void;
    
    /**
    * Adds a delete operation to the batch.
    * @param {object}             entity              The entity.
    */
    deleteEntity(entity: any, options?: TableBatch.InsertOptions): void;
    
    /**
    * Adds a merge operation to the batch.
    * @param {object}             entity              The entity.
    */
    mergeEntity(entity: any, options?: TableBatch.InsertOptions): void;
    
    /**
    * Adds a replace operation to the batch.
    * @param {object}             entity              The entity.
    */
    replaceEntity(entity: any, options?: TableBatch.InsertOptions): void;
    
    /**
    * Adds an insertOrReplace operation to the batch.
    * @param {object}             entity              The entity.
    */
    insertOrReplaceEntity(entity: any, options?: TableBatch.InsertOptions): void;
    
    /**
    * Adds an insertOrMerge operation to the batch.
    * @param {object}             entity              The entity.
    */
    insertOrMergeEntity(entity: any, options?: TableBatch.InsertOptions): void;
}

namespace TableBatch {
    export interface Operation {
        type: string;
        entity: any;
        options: any;
    }
    
    export interface IProperty<T> {
        _: T;
        $: string;
    }
    
    export interface RetrieveOptions {
        /** The payload format to use for the request. */
        payloadFormat?: string;
        
        /**
         * Given the partition key, row key, property name, property value, and the property Edm type if given by the service, returns the Edm type of the property.
         * @param {object}  pk          The partition key.
         * @param {object}  rk          The row key.
         * @param {string}  name        The property name.
         * @param {object}  value       The property value.
         * @param {string}  type        The EDM type.
         */
        propertyResolver?: (pk: IProperty<string>, rk: IProperty<string>, name: string, value: any, type?: string) => string;
        
        /**
         * The entity resolver. Given the single entity, returns a modified object.
         * @param {object}  entity      The entity to resolve.
         */
        entityResolver?: (entity: any) => any;
    }
    
    export interface InsertOptions extends RetrieveOptions {
        /** Whether or not to return the entity upon a successful insert. Inserts only, default to false. */
        echoContent?: boolean;
    }
}

export = TableBatch;
}
declare module 'azure-storage/lib/services/table/tablebatch' {
import main = require('~azure-storage/lib/services/table/tablebatch');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/table/tablequery.d.ts
declare module '~azure-storage/lib/services/table/tablequery' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

class TableQuery {
    /**
     * @constructor
     * Creates a new TableQuery object.
     */
    constructor();
    
    /**
    * Specifies the select clause. If no arguments are given, all fields will be selected.
    *
    * @param {array} fields The fields to be selected.
    * @return {TableQuery} A table query object with the select clause.
    */
    select(...fields: string[]): this;
    
    /**
     * Specifies the top clause.
     *
     * @param {int} top The number of items to fetch.
     * @return {TableQuery} A table query object with the top clause.
     */
    top(top: number): this;
    
    /**
     * Specifies the where clause.
     *
     * Valid type specifier strings include: ?string?, ?bool?, ?int32?, ?double?, ?date?, ?guid?, ?int64?, ?binary?
     * A type must be specified for guid, int64, and binaries or the filter produced will be incorrect.
     *
     * @param {string}       condition   The condition string.
     * @param {string|array} values      Value(s) to insert in question mark (?) parameters.
     * @return {TableQuery}  A table query object with the where clause.
     */
    where(condition: string, ...values: TableQuery.QueryValue[]): this;
    
    /**
     * Generates a property filter condition string for an 'int' value.
     *
     * @param {string}       propertyName   A string containing the name of the property to compare.
     * @param {string}       operation      A string containing the comparison operator to use. 
     *                                      See Constants.TableConstants.QueryComparisons for a list of allowed operations.
     * @param {string|int}   value          An 'int' containing the value to compare with the property.
     * @return {string} A string containing the formatted filter condition.
     */
    static int32Filter(propertyName: string, operation: string, value: string | number): string;
    
    /**
     * Generates a property filter condition string for an 'int64' value.
     *
     * @param {string}       propertyName   A string containing the name of the property to compare.
     * @param {string}       operation      A string containing the comparison operator to use. 
     *                                      See Constants.TableConstants.QueryComparisons for a list of allowed operations.
     * @param {string|int64} value          An 'int64' containing the value to compare with the property.
     * @return {string} A string containing the formatted filter condition.
     */
    static int64Filter(propertyName: string, operation: string, value: string | number): string;
    
    /**
     * Generates a property filter condition string for a 'double' value.
     *
     * @param {string}       propertyName   A string containing the name of the property to compare.
     * @param {string}       operation      A string containing the comparison operator to use. 
     *                                      See Constants.TableConstants.QueryComparisons for a list of allowed operations.
     * @param {string|double}value          A 'double' containing the value to compare with the property.
     * @return {string} A string containing the formatted filter condition.
     */
    static doubleFilter(propertyName: string, operation: string, value: string | number): string;
    
    /**
     * Generates a property filter condition string for a 'boolean' value.
     *
     * @param {string}       propertyName   A string containing the name of the property to compare.
     * @param {string}       operation      A string containing the comparison operator to use. 
     *                                      See Constants.TableConstants.QueryComparisons for a list of allowed operations.
     * @param {string|boolean}value         A 'boolean' containing the value to compare with the property.
     * @return {string} A string containing the formatted filter condition.
     */
    static booleanFilter(propertyName: string, operation: string, value: string | boolean): string;
    
    /**
     * Generates a property filter condition string for a 'date' value.
     *
     * @param {string}       propertyName   A string containing the name of the property to compare.
     * @param {string}       operation      A string containing the comparison operator to use. 
     *                                      See Constants.TableConstants.QueryComparisons for a list of allowed operations.
     * @param {string|date}  value          A 'datetime' containing the value to compare with the property.
     * @return {string} A string containing the formatted filter condition.
     */
    static dateFilter(propertyName: string, operation: string, value: string | Date): string;
    
    /**
     * Generates a property filter condition string for a 'guid' value.
     *
     * @param {string}       propertyName   A string containing the name of the property to compare.
     * @param {string}       operation      A string containing the comparison operator to use. 
     *                                      See Constants.TableConstants.QueryComparisons for a list of allowed operations.
     * @param {string|guid}  value          An 'guid' containing the value to compare with the property.
     * @return {string} A string containing the formatted filter condition.
     */
    static guidFilter(propertyName: string, operation: string, value: string): string;
    
    /**
     * Generates a property filter condition string for a 'binary' value.
     *
     * @param {string}       propertyName   A string containing the name of the property to compare.
     * @param {string}       operation      A string containing the comparison operator to use. 
     *                                      See Constants.TableConstants.QueryComparisons for a list of allowed operations.
     * @param {string|Buffer}value          A 'binary' containing the value to compare with the property.
     * @return {string} A string containing the formatted filter condition.
     */
    static binaryFilter(propertyName: string, operation: string, value: string | Buffer): string;
    
    /**
     * Generates a property filter condition string for a 'string' value.
     *
     * @param {string}       propertyName   A string containing the name of the property to compare.
     * @param {string}       operation      A string containing the comparison operator to use. 
     *                                      See Constants.TableConstants.QueryComparisons for a list of allowed operations.
     * @param {string}       value          A 'string' containing the value to compare with the property.
     * @return {string} A string containing the formatted filter condition.
     */
    static stringFilter(propertyName: string, operation: string, value: string): string;
    
    /**
     * Creates a filter condition using the specified logical operator on two filter conditions.
     *
     * @param {string}       filterA          A string containing the first formatted filter condition.
     * @param {string}       operatorString   A string containing the operator to use (AND, OR).
     * @param {string}       filterB          A string containing the second formatted filter condition.
     * @return {string} A string containing the combined filter expression.
     */
    static combineFilters(filterA: string, operatorString: string, filterB: string): string;
    
    /**
     * Specifies an AND where condition.
     *
     * Valid type specifier strings include: ?string?, ?bool?, ?int32?, ?double?, ?date?, ?guid?, ?int64?, ?binary?
     * A type must be specified for guid, int64, and binaries or the filter produced will be incorrect.
     *
     * @param {string}       condition   The condition string.
     * @param {string|array} values      Value(s) to insert in question mark (?) parameters.
     * @return {TableQuery}  A table query object with the where clause.
     */
    and(condition: string, ...values: TableQuery.QueryValue[]): this;
    
    /**
     * Specifies an OR where condition.
     *
     * Valid type specifier strings include: ?string?, ?bool?, ?int32?, ?double?, ?date?, ?guid?, ?int64?, ?binary?
     * A type must be specified for guid, int64, and binaries or the filter produced will be incorrect.
     *
     * @param {string}       condition   The condition string.
     * @param {string|array} values      Value(s) to insert in question mark (?) parameters.
     * @return {TableQuery}  A table query object with the where clause.
     */
    or(condition: string, ...values: TableQuery.QueryValue[]): this;
    
    /**
     * Returns the query string object for the query.
     *
     * @return {object} JSON object representing the query string arguments for the query.
     */
    toQueryObject(): TableQuery.QueryObject;
}

namespace TableQuery {
    export type QueryValue = string | number | boolean | Date | Buffer;
    
    export interface QueryObject {
        $select: string;
        $filter: string;
        $top: number;
    }
}

export = TableQuery;
}
declare module 'azure-storage/lib/services/table/tablequery' {
import main = require('~azure-storage/lib/services/table/tablequery');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/table/tableutilities.d.ts
declare module '~azure-storage/lib/services/table/tableutilities' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* Defines constants; enums; and utility functions for use with the Table service.
* @namespace TableUtilities
*/

/**
  * Permission types.
  *
  * @const
  * @enum {string}
  */
export const SharedAccessPermissions: {
    /**
    * @const
    * @default "r"
    */
    QUERY: string;
    /**
    * @const
    * @default "a"
    */
    ADD: string;
    /**
    * @const
    * @default "u"
    */
    UPDATE: string;
    /**
    * @const
    * @default "d"
    */
    DELETE: string;
};

/**
* Payload Format.
*
* @const
* @enum {string}
*/
export const PayloadFormat: {
    /**
    * @const
    * @default "application/json;odata=fullmetadata"
    */
    FULL_METADATA: string;
    /**
    * @const
    * @default "application/json;odata=minimalmetadata"
    */
    MINIMAL_METADATA: string;
    /**
    * @const
    * @default "application/json;odata=nometadata"
    */
    NO_METADATA: string;
};

/**
* Defines the set of Boolean operators for constructing queries.
*
* @const
* @enum {string}
*/
export const TableOperators: {
    /**
    * @const
    * @default "and"
    */
    AND: string;
    /**
    * @const
    * @default "not"
    */
    NOT: string;
    /**
    * @const
    * @default "or"
    */
    OR: string;
};

/**
* Filter property comparison operators.
*
* @const
* @enum {string}
*/
export const QueryComparisons: {
    /**
    * @const
    * @default "eq"
    */
    EQUAL: string;
    /**
    * @const
    * @default "ne"
    */
    NOT_EQUAL: string;
    /**
    * @const
    * @default "gt"
    */
    GREATER_THAN: string;
    /**
    * @const
    * @default "ge"
    */
    GREATER_THAN_OR_EQUAL: string;
    /**
    * @const
    * @default "lt"
    */
    LESS_THAN: string;
    /**
    * @const
    * @default "le"
    */
    LESS_THAN_OR_EQUAL: string;
};

/**
* Edm types.
*
* @const
* @enum {string}
*/
export const EdmType: {
    /**
    * @const
    * @default "Edm.String"
    */
    STRING: string;
    /**
    * @const
    * @default "Edm.Binary"
    */
    BINARY: string;
    /**
    * @const
    * @default "Edm.Int64"
    */
    INT64: string;
    /**
    * @const
    * @default "Edm.Int32"
    */
    INT32: string;
    /**
    * @const
    * @default "Edm.Double"
    */
    DOUBLE: string;
    /**
    * @const
    * @default "Edm.DateTime"
    */
    DATETIME: string;
    /**
    * @const
    * @default "Edm.Guid"
    */
    GUID: string;
    /**
    * @const
    * @default "Edm.Boolean"
    */
    BOOLEAN: string;
};

/**
* A helper to create table entities.
*/
export namespace entityGenerator {
    export class EntityProperty<T> {
        _: T;
        $: string;

        constructor(value: T, type?: string);
    }
    export interface EntityPropertyInterface {
        <T>(): EntityProperty<T>;
    }

    export function Int32(value: string | number): EntityProperty<number>;
    export function Int64(value: string | number): EntityProperty<number>;
    export function Binary(value: string | Buffer): EntityProperty<Buffer>;
    export function Boolean(value: string | boolean): EntityProperty<boolean>;
    export function String(value: any): EntityProperty<string>;
    export function Guid(value: string): EntityProperty<string>;
    export function Double(value: string | number): EntityProperty<number>;
    export function DateTime(value: string | Date): EntityProperty<Date>;
}
}
declare module 'azure-storage/lib/services/table/tableutilities' {
export * from '~azure-storage/lib/services/table/tableutilities';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/blob/blobservice.d.ts
declare module '~azure-storage/lib/services/blob/blobservice' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

import { StorageServiceClient, AccessCondition, SpeedSummary } from '~azure-storage/lib/common/common';
import { StorageError } from '~azure-storage/lib/common/errors/errors';

type ErrorOrResult<T> = StorageServiceClient.ErrorOrResult<T>;
type ErrorOrList<T> = StorageServiceClient.ErrorOrList<T>;

/**
* @class
* @extends {StorageServiceClient}
* The BlobService class is used to perform operations on the Microsoft Azure Blob Service.
* The Blob Service provides storage for binary large objects, and provides
* functions for working with data stored in blobs as either streams or pages of data.
* 
* For more information on the Blob Service, as well as task focused information on using it in a Node.js application, see
* [How to Use the Blob Service from Node.js](http://azure.microsoft.com/en-us/documentation/articles/storage-nodejs-how-to-use-blob-storage/).
*/
class BlobService extends StorageServiceClient {
    /** The default maximum size, in bytes, of a blob before it must be separated into blocks. */
    singleBlobPutThresholdInBytes: number;
    /** The default timeout interval, in milliseconds, to use for request made via the Blob service. */
    defaultTimeoutIntervalInMs: number;
    /** The default maximum execution time across all potential retries, for requests made via the Blob service. */
    defaultMaximumExecutionTimeInMs: number;
    /** The default location mode for requests made via the Blob service. */
    defaultLocationMode: number;
    /** 
     * The number of parallel operations that may be performed when uploading a blob that is greater than  the value specified by the 
     * singleBlobPutThresholdInBytes property in size. 
     */
    parallelOperationThreadCount: number;
    /**
     * Determines whether the Nagle algorithm is used for requests made via the Blob service; true to use the Nagle algorithm; otherwise, false. 
     * The default value is false.
     */
    useNagleAlgorithm: boolean;
    
    // ***********************************************************
    // ** STATIC
    // ***********************************************************
    
    static SpeedSummary: typeof SpeedSummary;
    
    /**
    * Creates a new BlobService object using the AZURE_STORAGE_CONNECTION_STRING or AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY environment variables.
    * @constructor
    */
    constructor();
    /**
    * Creates a new BlobService object using the given connection string.
    *
    * @constructor
    * @param {string} connectionString                    The storage account or the connection string.
    */    
    constructor(connectionString: string);
    /**
    * Creates a new BlobService object using the given parameters.
    *
    * @constructor
    * @param {string} [storageAccount]                    The storage account.
    * @param {string} [storageAccessKey]                  The storage access key.
    * @param {string|object} [host]                       The host address. To define primary only, pass a string. 
    *                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
    * @param {string} [sasToken]                          The Shared Access Signature token.
    */
    constructor(storageAccount: string, storageAccessKey: string, host?: StorageServiceClient.HostConfiguration, sasToken?: string);
    
    
    // ***********************************************************
    // ** SERVICE METHODS
    // ***********************************************************
    
    /**
    * Gets the service stats for a storage account’s Blob service.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ServiceStats}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getServiceStats(callback: ErrorOrResult<StorageServiceClient.ServiceStats>): void;
    /**
    * Gets the service stats for a storage account’s Blob service.
    * @param {object}         options                               The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ServiceStats}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getServiceStats(options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<StorageServiceClient.ServiceStats>): void;
    
    
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getServiceProperties(callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {object}       options                                 The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getServiceProperties(options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    
    
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {ServiceOptions}     options                                  The request options.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    // ***********************************************************
    // ** CONTAINER LIST METHODS
    // ***********************************************************
    
    /**
    * Lists a segment containing a collection of container items under the specified account.
    *
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[containers]{@link ContainerResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listContainersSegmented(currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<BlobService.ContainerResult>): void;
    /**
    * Lists a segment containing a collection of container items under the specified account.
    *
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[containers]{@link ContainerResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listContainersSegmented(currentToken: StorageServiceClient.ContinuationToken, options: BlobService.ListContainerOptions, callback: ErrorOrList<BlobService.ContainerResult>): void;
    
    
    /**
    * Lists a segment containing a collection of container items whose names begin with the specified prefix under the specified account.
    *
    * @param {string}             prefix                                      The prefix of the container name.
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[containers]{@link ContainerResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listContainersSegmentedWithPrefix(prefix: string, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<BlobService.ContainerResult>): void;
    /**
    * Lists a segment containing a collection of container items whose names begin with the specified prefix under the specified account.
    *
    * @param {string}             prefix                                      The prefix of the container name.
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[containers]{@link ContainerResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listContainersSegmentedWithPrefix(prefix: string, currentToken: StorageServiceClient.ContinuationToken, options: BlobService.ListContainerOptions, callback: ErrorOrList<BlobService.ContainerResult>): void;
    
    // ***********************************************************
    // ** CONTAINER METHODS
    // ***********************************************************
    
    /**
    * Checks whether or not a container exists on the service.
    *
    * @param {string}             container                               The container name.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                     the container information including `exists` boolean member. 
    *                                                                     `response` will contain information related to this operation.
    */
    doesContainerExist(container: string, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    /**
    * Checks whether or not a container exists on the service.
    *
    * @param {string}             container                               The container name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                     the container information including `exists` boolean member. 
    *                                                                     `response` will contain information related to this operation.
    */
    doesContainerExist(container: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    
    /**
    * Creates a new container under the specified account.
    * If a container with the same name already exists, the operation fails.
    *
    * @param {string}             container                           The container name.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                 the container information.
    *                                                                 `response` will contain information related to this operation.
    */
    createContainer(container: string, callbak: ErrorOrResult<BlobService.ContainerResult>): void;
    /**
    * Creates a new container under the specified account.
    * If a container with the same name already exists, the operation fails.
    *
    * @param {string}             container                           The container name.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                 the container information.
    *                                                                 `response` will contain information related to this operation.
    */
    createContainer(container: string, options: BlobService.ContainerOptions, callbak: ErrorOrResult<BlobService.ContainerResult>): void;
    
    /**
    * Creates a new container under the specified account if the container does not exists.
    *
    * @param {string}             container                           The container name.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                 the container information.
    *                                                                 `response` will contain information related to this operation.
    */
    createContainerIfNotExists(container: string, callbak: ErrorOrResult<BlobService.ContainerResult>): void;
    /**
    * Creates a new container under the specified account if the container does not exists.
    *
    * @param {string}             container                           The container name.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                 the container information.
    *                                                                 `response` will contain information related to this operation.
    */
    createContainerIfNotExists(container: string, options: BlobService.ContainerOptions, callbak: ErrorOrResult<BlobService.ContainerResult>): void;
    
    /**
    * Retrieves a container and its properties from a specified account.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             container                           The container name.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                 information for the container.
    *                                                                 `response` will contain information related to this operation.
    */
    getContainerProperties(container: string, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    /**
    * Retrieves a container and its properties from a specified account.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             container                           The container name.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                 information for the container.
    *                                                                 `response` will contain information related to this operation.
    */
    getContainerProperties(container: string, options: BlobService.LeaseOptions, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    
    /**
    * Returns all user-defined metadata for the container.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             container                                 The container name.
    * @param {errorOrResult}      callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                       information for the container.
    *                                                                       `response` will contain information related to this operation.
    */
    getContainerMetadata(container: string, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    /**
    * Returns all user-defined metadata for the container.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             container                                 The container name.
    * @param {object}             options                                   The request options.
    * @param {errorOrResult}      callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise `[result]{@link ContainerResult}` will contain
    *                                                                       information for the container.
    *                                                                       `response` will contain information related to this operation.
    */
    getContainerMetadata(container: string, options: BlobService.LeaseOptions, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    
    /**
    * Sets the container's metadata.
    *
    * Calling the Set Container Metadata operation overwrites all existing metadata that is associated with the container.
    * It's not possible to modify an individual name/value pair.
    *
    * @param {string}             container                           The container name.
    * @param {object}             metadata                            The metadata key/value pairs.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise 
    *                                                                 `response` will contain information related to this operation.
    */
    setContainerMetadata(container: string, metadata: Object, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    /**
    * Sets the container's metadata.
    *
    * Calling the Set Container Metadata operation overwrites all existing metadata that is associated with the container.
    * It's not possible to modify an individual name/value pair.
    *
    * @param {string}             container                           The container name.
    * @param {object}             metadata                            The metadata key/value pairs.
    * @param {object}             options                             The request options.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise 
    *                                                                 `response` will contain information related to this operation.
    */
    setContainerMetadata(container: string, metadata: Object, options: BlobService.AccessConditionsOptions, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    
    /**
    * Gets the container's ACL.
    *
    * @param {string}             container                           The container name.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ContainerAclResult}` will contain
    *                                                                 information for the container.
    *                                                                 `response` will contain information related to this operation.
    */
    getContainerAcl(container: string, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    /**
    * Gets the container's ACL.
    *
    * @param {string}             container                           The container name.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ContainerAclResult}` will contain
    *                                                                 information for the container.
    *                                                                 `response` will contain information related to this operation.
    */
    getContainerAcl(container: string, options: BlobService.LeaseOptions, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    
    /**
    * Updates the container's ACL.
    *
    * @param {string}                         container                           The container name.
    * @param {Object.<string, AccessPolicy>}  signedIdentifiers                   The container ACL settings. See `[AccessPolicy]{@link AccessPolicy}` for detailed information.
    * @param {errorOrResult}                  callback                            `error` will contain information
    *                                                                             if an error occurs; otherwise `[result]{@link ContainerAclResult}` will contain
    *                                                                             information for the container.
    *                                                                             `response` will contain information related to this operation.
    */
    setContainerAcl(container: string, signedIdentifiers: StorageServiceClient.SignedIdentifiers, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    /**
    * Updates the container's ACL.
    *
    * @param {string}                         container                           The container name.
    * @param {Object.<string, AccessPolicy>}  signedIdentifiers                   The container ACL settings. See `[AccessPolicy]{@link AccessPolicy}` for detailed information.
    * @param {object}                         options                             The request options.
    * @param {errorOrResult}                  callback                            `error` will contain information
    *                                                                             if an error occurs; otherwise `[result]{@link ContainerAclResult}` will contain
    *                                                                             information for the container.
    *                                                                             `response` will contain information related to this operation.
    */
    setContainerAcl(container: string, signedIdentifiers: StorageServiceClient.SignedIdentifiers, options: BlobService.SetContainerAclOptions, callback: ErrorOrResult<BlobService.ContainerResult>): void;
    
    /**
    * Marks the specified container for deletion.
    * The container and any blobs contained within it are later deleted during garbage collection.
    *
    * @param {string}             container                           The container name.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteContainer(container: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified container for deletion.
    * The container and any blobs contained within it are later deleted during garbage collection.
    *
    * @param {string}             container                           The container name.
    * @param {object}             options                             The request options.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteContainer(container: string, options: BlobService.AccessConditionsOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Marks the specified container for deletion if it exists.
    * The container and any blobs contained within it are later deleted during garbage collection.
    *
    * @param {string}             container                           The container name.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteContainerIfExists(container: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified container for deletion if it exists.
    * The container and any blobs contained within it are later deleted during garbage collection.
    *
    * @param {string}             container                           The container name.
    * @param {object}             options                             The request options.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteContainerIfExists(container: string, options: BlobService.AccessConditionsOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    // ***********************************************************
    // ** BLOB LIST METHODS
    // ***********************************************************
    
    /**
    * Lists a segment containing a collection of blob directory items in the container.
    *
    * @param {string}             container                         The container name.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                               `entries`  gives a list of `[directories]{@link DirectoryResult}` and the `continuationToken` is used for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listBlobDirectoriesSegmented(container: string, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<BlobService.DirectoryResult>): void;
    /**
    * Lists a segment containing a collection of blob directory items in the container.
    *
    * @param {string}             container                         The container name.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                           The request options.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                               `entries`  gives a list of `[directories]{@link DirectoryResult}` and the `continuationToken` is used for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listBlobDirectoriesSegmented(container: string, currentToken: StorageServiceClient.ContinuationToken, options: BlobService.ListBlobOptions, callback: ErrorOrList<BlobService.DirectoryResult>): void;
    
    /**
    * Lists a segment containing a collection of blob directory items in the container.
    *
    * @param {string}             container                         The container name.
    * @param {string}             prefix                            The prefix of the blob name.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                               `entries`  gives a list of `[directories]{@link DirectoryResult}` and the `continuationToken` is used for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listBlobDirectoriesSegmentedWithPrefix(container: string, prefix: string, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<BlobService.DirectoryResult>): void;
    /**
    * Lists a segment containing a collection of blob directory items in the container.
    *
    * @param {string}             container                         The container name.
    * @param {string}             prefix                            The prefix of the blob name.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                           The request options.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                               `entries`  gives a list of `[directories]{@link DirectoryResult}` and the `continuationToken` is used for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listBlobDirectoriesSegmentedWithPrefix(container: string, prefix: string, currentToken: StorageServiceClient.ContinuationToken, options: BlobService.ListBlobOptions, callback: ErrorOrList<BlobService.DirectoryResult>): void;
    
    /**
    * Lists a segment containing a collection of blob directory items in the container.
    *
    * @param {string}             container                         The container name.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                               `entries`  gives a list of `[blobs]{@link BlobResult}` and the `continuationToken` is used for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listBlobsSegmented(container: string, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<BlobService.BlobResult>): void;
    /**
    * Lists a segment containing a collection of blob directory items in the container.
    *
    * @param {string}             container                         The container name.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                           The request options.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                               `entries`  gives a list of `[blobs]{@link BlobResult}` and the `continuationToken` is used for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listBlobsSegmented(container: string, currentToken: StorageServiceClient.ContinuationToken, options: BlobService.ListBlobOptions, callback: ErrorOrList<BlobService.BlobResult>): void;
    
    /**
    * Lists a segment containing a collection of blob directory items in the container.
    *
    * @param {string}             container                         The container name.
    * @param {string}             prefix                            The prefix of the blob name.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                               `entries`  gives a list of `[blobs]{@link BlobResult}` and the `continuationToken` is used for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listBlobsSegmentedWithPrefix(container: string, prefix: string, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<BlobService.BlobResult>): void;
    /**
    * Lists a segment containing a collection of blob directory items in the container.
    *
    * @param {string}             container                         The container name.
    * @param {string}             prefix                            The prefix of the blob name.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                           The request options.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                               `entries`  gives a list of `[blobs]{@link BlobResult}` and the `continuationToken` is used for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listBlobsSegmentedWithPrefix(container: string, prefix: string, currentToken: StorageServiceClient.ContinuationToken, options: BlobService.ListBlobOptions, callback: ErrorOrList<BlobService.BlobResult>): void;
    
    // ***********************************************************
    // ** LEASE METHODS
    // ***********************************************************
    
    /**
    * Acquires a new lease. If container and blob are specified, acquires a blob lease. Otherwise, if only container is specified and blob is null, acquires a container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link LeaseResult}` will contain
    *                                                                         the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    acquireLease(container: string, blob: string, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    /**
    * Acquires a new lease. If container and blob are specified, acquires a blob lease. Otherwise, if only container is specified and blob is null, acquires a container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link LeaseResult}` will contain
    *                                                                         the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    acquireLease(container: string, blob: string, options: BlobService.AcquireLeaseOptions, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    
    /**
    * Renews an existing lease. If container and blob are specified, renews the blob lease. Otherwise, if only container is specified and blob is null, renews the container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {string}             leaseId                                     The lease identifier. Must be a GUID.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link LeaseResult}` will contain
    *                                                                         the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    renewLease(container: string, blob: string, leaseId: string, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    /**
    * Renews an existing lease. If container and blob are specified, renews the blob lease. Otherwise, if only container is specified and blob is null, renews the container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {string}             leaseId                                     The lease identifier. Must be a GUID.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link LeaseResult}` will contain
    *                                                                         the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    renewLease(container: string, blob: string, leaseId: string, options: StorageServiceClient.AccessConditionsOptions, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    
    /**
    * Changes the lease ID of an active lease. If container and blob are specified, changes the blob lease. Otherwise, if only container is specified and blob is null, changes the 
    * container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {string}             leaseId                                     The current lease identifier.
    * @param {string}             proposedLeaseId                             The proposed lease identifier. Must be a GUID. 
    * @param {errorOrResult}      callback                                    `error` will contain information if an error occurs; 
    *                                                                         otherwise `[result]{@link LeaseResult}` will contain  the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    changeLease(container: string, blob: string, leaseId: string, proposedLeaseId: string, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    
    /**
    * Changes the lease ID of an active lease. If container and blob are specified, changes the blob lease. Otherwise, if only container is specified and blob is null, changes the 
    * container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {string}             leaseId                                     The current lease identifier.
    * @param {string}             proposedLeaseId                             The proposed lease identifier. Must be a GUID. 
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information if an error occurs; 
    *                                                                         otherwise `[result]{@link LeaseResult}` will contain  the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    changeLease(container: string, blob: string, leaseId: string, proposedLeaseId: string, options: StorageServiceClient.AccessConditionsOptions, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    
    /**
    * Releases the lease. If container and blob are specified, releases the blob lease. Otherwise, if only container is specified and blob is null, releases the container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {string}             leaseId                                     The lease identifier.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link LeaseResult}` will contain
    *                                                                         the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    releaseLease(container: string, blob: string, leaseId: string, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    /**
    * Releases the lease. If container and blob are specified, releases the blob lease. Otherwise, if only container is specified and blob is null, releases the container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {string}             leaseId                                     The lease identifier.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link LeaseResult}` will contain
    *                                                                         the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    releaseLease(container: string, blob: string, leaseId: string, options: StorageServiceClient.AccessConditionsOptions, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    
    /**
    * Breaks the lease but ensures that another client cannot acquire a new lease until the current lease period has expired. If container and blob are specified, breaks the blob lease. 
    * Otherwise, if only container is specified and blob is null, breaks the container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link LeaseResult}` will contain
    *                                                                         the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    breakLease(container: string, blob: string, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    /**
    * Breaks the lease but ensures that another client cannot acquire a new lease until the current lease period has expired. If container and blob are specified, breaks the blob lease. 
    * Otherwise, if only container is specified and blob is null, breaks the container lease.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link LeaseResult}` will contain
    *                                                                         the lease information.
    *                                                                         `response` will contain information related to this operation.
    */
    breakLease(container: string, blob: string, options: BlobService.BreakLeaseOptions, callback: ErrorOrResult<BlobService.LeaseResult>): void;
    
    // ***********************************************************
    // ** BLOB METHODS
    // ***********************************************************
    
    /**
    * Returns all user-defined metadata, standard HTTP properties, and system properties for the blob.
    * It does not return or modify the content of the blob.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         information about the blob.
    *                                                                         `response` will contain information related to this operation.
    */
    getBlobProperties(container: string, blob: string, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Returns all user-defined metadata, standard HTTP properties, and system properties for the blob.
    * It does not return or modify the content of the blob.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         information about the blob.
    *                                                                         `response` will contain information related to this operation.
    */
    getBlobProperties(container: string, blob: string, options: BlobService.BlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Returns all user-defined metadata for the specified blob or snapshot.
    * It does not return or modify the content of the blob.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         information about the blob.
    *                                                                         `response` will contain information related to this operation.
    */
    getBlobMetadata(container: string, blob: string, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Returns all user-defined metadata for the specified blob or snapshot.
    * It does not return or modify the content of the blob.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         information about the blob.
    *                                                                         `response` will contain information related to this operation.
    */
    getBlobMetadata(container: string, blob: string, options: BlobService.BlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Sets user-defined properties for the specified blob or snapshot.
    * It does not modify or return the content of the blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             properties                                  The blob properties to set.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         information about the blob.
    *                                                                         `response` will contain information related to this operation.
    */
    setBlobProperties(container: string, blob: string, properties: BlobService.BlobProperties, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Sets user-defined properties for the specified blob or snapshot.
    * It does not modify or return the content of the blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             properties                                  The blob properties to set.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         information about the blob.
    *                                                                         `response` will contain information related to this operation.
    */
    setBlobProperties(container: string, blob: string, properties: BlobService.BlobProperties, options: BlobService.BlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Sets user-defined metadata for the specified blob or snapshot.
    * It does not modify or return the content of the blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             metadata                                    The metadata key/value pairs.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         information about the blob.
    *                                                                         `response` will contain information related to this operation.
    */
    setBlobMetadata(container: string, blob: string, metadata: Object, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Sets user-defined metadata for the specified blob or snapshot.
    * It does not modify or return the content of the blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             metadata                                    The metadata key/value pairs.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         information about the blob.
    *                                                                         `response` will contain information related to this operation.
    */
    setBlobMetadata(container: string, blob: string, metadata: Object, options: BlobService.BlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    
    /**
    * Downloads a blob into a file.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {string}             localFileName                               The local path to the file to be downloaded.
    * @param {errorOrResult}      callback                                    `error` will contain information if an error occurs; 
    *                                                                         otherwise `[result]{@link BlobResult}` will contain the blob information.
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    getBlobToLocalFile(container: string, blob: string, localFileName: string, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Downloads a blob into a file.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {string}             localFileName                               The local path to the file to be downloaded.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information if an error occurs; 
    *                                                                         otherwise `[result]{@link BlobResult}` will contain the blob information.
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    getBlobToLocalFile(container: string, blob: string, localFileName: string, options: BlobService.DownloadBlobToFileOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Provides a stream to read from a blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @return {Stream}
    */
    createReadStream(container: string, blob: string): NodeJS.ReadableStream;
    /**
    * Provides a stream to read from a blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {errorOrResult}      callback                                    `error` will contain information if an error occurs; 
    *                                                                         otherwise `[result]{@link BlobResult}` will contain the blob information.
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    createReadStream(container: string, blob: string, callback: ErrorOrResult<BlobService.BlobResult>): NodeJS.ReadableStream;
    /**
    * Provides a stream to read from a blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @return {Stream}
    */
    createReadStream(container: string, blob: string, options: BlobService.DownloadBlobOptions): NodeJS.ReadableStream;
    /**
    * Provides a stream to read from a blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information if an error occurs; 
    *                                                                         otherwise `[result]{@link BlobResult}` will contain the blob information.
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    createReadStream(container: string, blob: string, options: BlobService.DownloadBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): NodeJS.ReadableStream;
    
    /**
    * Downloads a blob into a stream.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {Stream}             writeStream                                 The write stream.
    * @param {errorOrResult}      callback                                    `error` will contain information if an error occurs; 
    *                                                                         otherwise `[result]{@link BlobResult}` will contain the blob information.
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    getBlobToStream(container: string, blob: string, writeStream: NodeJS.WritableStream, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Downloads a blob into a stream.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {Stream}             writeStream                                 The write stream.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information if an error occurs; 
    *                                                                         otherwise `[result]{@link BlobResult}` will contain the blob information.
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    getBlobToStream(container: string, blob: string, writeStream: NodeJS.WritableStream, options: BlobService.DownloadBlobToFileOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Downloads a blob into a text string.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {BlobService~blobToText}  callback                               `error` will contain information
    *                                                                         if an error occurs; otherwise `text` will contain the blob contents,
    *                                                                         and `[blockBlob]{@link BlobResult}` will contain
    *                                                                         the blob information.
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    getBlobToText(container: string, blob: string, callback: BlobService.BlobToTextCallback): SpeedSummary;
    /**
    * Downloads a blob into a text string.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {BlobService~blobToText}  callback                               `error` will contain information
    *                                                                         if an error occurs; otherwise `text` will contain the blob contents,
    *                                                                         and `[blockBlob]{@link BlobResult}` will contain
    *                                                                         the blob information.
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    getBlobToText(container: string, blob: string, options: BlobService.DownloadBlobOptions, callback: BlobService.BlobToTextCallback): SpeedSummary;
    
    
    /**
    * Marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection.
    * If a blob has snapshots, you must delete them when deleting the blob. Using the deleteSnapshots option, you can choose either to delete both the blob and its snapshots, 
    * or to delete only the snapshots but not the blob itself. If the blob has snapshots, you must include the deleteSnapshots option or the blob service will return an error
    * and nothing will be deleted. 
    * If you are deleting a specific snapshot using the snapshotId option, the deleteSnapshots option must NOT be included.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; `response` will contain information related to this operation.
    */
    deleteBlob(container: string, blob: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified blob or snapshot for deletion. The blob is later deleted during garbage collection.
    * If a blob has snapshots, you must delete them when deleting the blob. Using the deleteSnapshots option, you can choose either to delete both the blob and its snapshots, 
    * or to delete only the snapshots but not the blob itself. If the blob has snapshots, you must include the deleteSnapshots option or the blob service will return an error
    * and nothing will be deleted. 
    * If you are deleting a specific snapshot using the snapshotId option, the deleteSnapshots option must NOT be included.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; `response` will contain information related to this operation.
    */
    deleteBlob(container: string, blob: string, options: BlobService.DeleteBlobOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Checks whether or not a blob exists on the service.
    *
    * @param {string}             container                               The container name.
    * @param {string}             blob                                    The blob name.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link BlobResult}` will contain 
    *                                                                     the blob information including the `exists` boolean member. 
    *                                                                     `response` will contain information related to this operation.
    */
    doesBlobExist(container: string, blob: string, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Checks whether or not a blob exists on the service.
    *
    * @param {string}             container                               The container name.
    * @param {string}             blob                                    The blob name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link BlobResult}` will contain 
    *                                                                     the blob information including the `exists` boolean member. 
    *                                                                     `response` will contain information related to this operation.
    */
    doesBlobExist(container: string, blob: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Marks the specified blob or snapshot for deletion if it exists. The blob is later deleted during garbage collection.
    * If a blob has snapshots, you must delete them when deleting the blob. Using the deleteSnapshots option, you can choose either to delete both the blob and its snapshots, 
    * or to delete only the snapshots but not the blob itself. If the blob has snapshots, you must include the deleteSnapshots option or the blob service will return an error
    * and nothing will be deleted. 
    * If you are deleting a specific snapshot using the snapshotId option, the deleteSnapshots option must NOT be included.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; `response` will contain information related to this operation.
    */
    deleteBlobIfExists(container: string, blob: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified blob or snapshot for deletion if it exists. The blob is later deleted during garbage collection.
    * If a blob has snapshots, you must delete them when deleting the blob. Using the deleteSnapshots option, you can choose either to delete both the blob and its snapshots, 
    * or to delete only the snapshots but not the blob itself. If the blob has snapshots, you must include the deleteSnapshots option or the blob service will return an error
    * and nothing will be deleted. 
    * If you are deleting a specific snapshot using the snapshotId option, the deleteSnapshots option must NOT be included.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; `response` will contain information related to this operation.
    */
    deleteBlobIfExists(container: string, blob: string, options: BlobService.DeleteBlobOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Creates a read-only snapshot of a blob.
    *
    * @param {string}             container                             The container name.
    * @param {string}             blob                                  The blob name.
    * @param {errorOrResult}      callback                              `error` will contain information
    *                                                                   if an error occurs; otherwise `result` will contain
    *                                                                   the ID of the snapshot.
    *                                                                   `response` will contain information related to this operation.
    */
    createBlobSnapshot(container: string, blob: string, callback: ErrorOrResult<string>): void;
    /**
    * Creates a read-only snapshot of a blob.
    *
    * @param {string}             container                             The container name.
    * @param {string}             blob                                  The blob name.
    * @param {object}             options                               The request options.
    * @param {errorOrResult}      callback                              `error` will contain information
    *                                                                   if an error occurs; otherwise `result` will contain
    *                                                                   the ID of the snapshot.
    *                                                                   `response` will contain information related to this operation.
    */
    createBlobSnapshot(container: string, blob: string, options: BlobService.BlobSnapshotOptions, callback: ErrorOrResult<string>): void;
    
    
    /**
    * Starts to copy a blob to a destination within the storage account. The Copy Blob operation copies the entire committed blob.
    *
    * @param {string}             sourceUri                                 The source blob URI.
    * @param {string}             targetContainer                           The target container name.
    * @param {string}             targetBlob                                The target blob name.
    * @param {errorOrResult}      callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                       the blob information.
    *                                                                       `response` will contain information related to this operation.
    */
    startCopyBlob(sourceuri: string, targetContainer: string, targetBlob: string, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Starts to copy a blob to a destination within the storage account. The Copy Blob operation copies the entire committed blob.
    *
    * @param {string}             sourceUri                                 The source blob URI.
    * @param {string}             targetContainer                           The target container name.
    * @param {string}             targetBlob                                The target blob name.
    * @param {object}             options                                   The request options.
    * @param {errorOrResult}      callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                       the blob information.
    *                                                                       `response` will contain information related to this operation.
    */
    startCopyBlob(sourceuri: string, targetContainer: string, targetBlob: string, options: BlobService.CopyBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Abort a blob copy operation.
    *
    * @param {string}             container                                 The destination container name.
    * @param {string}             blob                                      The destination blob name.
    * @param {string}             copyId                                    The copy operation identifier.
    * @param {errorOrResult}      callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                       the blob information.
    *                                                                       `response` will contain information related to this operation.
    */
    abortCopyBlob(container: string, blob: string, copyId: string, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Abort a blob copy operation.
    *
    * @param {string}             container                                 The destination container name.
    * @param {string}             blob                                      The destination blob name.
    * @param {string}             copyId                                    The copy operation identifier.
    * @param {object}             options                                   The request options.
    * @param {errorOrResult}      callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                       the blob information.
    *                                                                       `response` will contain information related to this operation.
    */
    abortCopyBlob(container: string, blob: string, copyId: string, options: BlobService.LeaseOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    // ***********************************************************
    // ** URL METHODS
    // ***********************************************************
    
    /**
    * Retrieves a shared access signature token for the container or the blob.
    *
    * @param {string}                   container                                           The container name.
    * @param {string}                   blob                                                The blob name.
    * @param {object}                   sharedAccessPolicy                                  The shared access policy.
    * @param {object}                   [headers]                                           The optional header values to set for a blob returned wth this SAS.
    * @return {string}                                                                      The shared access signature query string. Note this string does not contain the leading "?".
    */
    generateSharedAccessSignature(container: string, blob: string, sharedAccessPolicy: StorageServiceClient.SharedAccessPolicy, headers?: BlobService.AccessPolicyHeaders): string;
    
    /**
    * Retrieves a blob or container URL.
    *
    * @param {string}                   container                The container name.
    * @param {string}                   [blob]                   The blob name.
    * @param {string}                   [sasToken]               The Shared Access Signature token.
    * @param {boolean}                  [primary]                A boolean representing whether to use the primary or the secondary endpoint.
    * @return {string}                                           The formatted URL string.
    */
    getUrl(container: string, blob?: string, sasToken?: string, primary?: boolean): string;
    
    // ***********************************************************
    // ** PAGE BLOB METHODS
    // ***********************************************************
    
    /**
    * Creates a page blob of the specified length. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {int}                length                                        The length of the page blob in bytes.
    * @param {errorOrResponse}    callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise 
    *                                                                           `response` will contain information related to this operation.
    */
    createPageBlob(container: string, blob: string, length: number, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Creates a page blob of the specified length. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {int}                length                                        The length of the page blob in bytes.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise 
    *                                                                           `response` will contain information related to this operation.
    */
    createPageBlob(container: string, blob: string, length: number, options: BlobService.CreateBlobOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Uploads a page blob from file. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                           The container name.
    * @param {string}             blob                                                The blob name.
    * @param (string)             localFileName                                       The local path to the file to be uploaded.
    * @param {errorOrResult}      callback                                            `error` will contain information
    *                                                                                 if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                                 the blob information.
    *                                                                                 `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createPageBlobFromLocalFile(container: string, blob: string, localFileName: string, callback: StorageServiceClient.ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Uploads a page blob from file. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                           The container name.
    * @param {string}             blob                                                The blob name.
    * @param (string)             localFileName                                       The local path to the file to be uploaded.
    * @param {object}             options                                             The request options.
    * @param {errorOrResult}      callback                                            `error` will contain information
    *                                                                                 if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                                 the blob information.
    *                                                                                 `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createPageBlobFromLocalFile(container: string, blob: string, localFileName: string, options: BlobService.UploadBlobOptions, callback: StorageServiceClient.ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Uploads a page blob from a stream. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param (Stream)             stream                                        Stream to the data to store.
    * @param {int}                streamLength                                  The length of the stream to upload.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createPageBlobFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, callback: StorageServiceClient.ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Uploads a page blob from a stream. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param (Stream)             stream                                        Stream to the data to store.
    * @param {int}                streamLength                                  The length of the stream to upload.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createPageBlobFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, options: BlobService.UploadBlobOptions, callback: StorageServiceClient.ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Provides a stream to write to a page blob. Assumes that the blob exists. 
    * If it does not, please create the blob using createPageBlob before calling this method or use createWriteStreamNewPageBlob.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @return {Stream}
    */
    createWriteStreamToExistingPageBlob(container: string, blob: string): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a page blob. Assumes that the blob exists. 
    * If it does not, please create the blob using createPageBlob before calling this method or use createWriteStreamNewPageBlob.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToExistingPageBlob(container: string, blob: string, callback: StorageServiceClient.ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a page blob. Assumes that the blob exists. 
    * If it does not, please create the blob using createPageBlob before calling this method or use createWriteStreamNewPageBlob.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @return {Stream}
    */
    createWriteStreamToExistingPageBlob(container: string, blob: string, options: BlobService.UploadBlobOptions): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a page blob. Assumes that the blob exists. 
    * If it does not, please create the blob using createPageBlob before calling this method or use createWriteStreamNewPageBlob.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToExistingPageBlob(container: string, blob: string, options: BlobService.UploadBlobOptions, callback: StorageServiceClient.ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    
    /**
    * Provides a stream to write to a page blob. Creates the blob before writing data. If the blob already exists on the service, it will be overwritten.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @return {Stream}
    */
    createWriteStreamToNewPageBlob(container: string, blob: string): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a page blob. Creates the blob before writing data with specified length. If the blob already exists on the service, it will be overwritten.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             length                                        The blob length.
    * @return {Stream}
    */
    createWriteStreamToNewPageBlob(container: string, blob: string, length: number): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a page blob. Creates the blob before writing data with specified length. If the blob already exists on the service, it will be overwritten.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             length                                        The blob length.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToNewPageBlob(container: string, blob: string, length: number, callback: StorageServiceClient.ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a page blob. Creates the blob before writing data with specified length. If the blob already exists on the service, it will be overwritten.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             length                                        The blob length.
    * @param {object}             options                                       The request options.
    * @return {Stream}
    */
    createWriteStreamToNewPageBlob(container: string, blob: string, length: number, options: BlobService.UploadBlobOptions): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a page blob. Creates the blob before writing data with specified length. If the blob already exists on the service, it will be overwritten.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             length                                        The blob length.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToNewPageBlob(container: string, blob: string, length: number, options: BlobService.UploadBlobOptions, callback: StorageServiceClient.ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    
    /**
    * Updates a page blob from a stream.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {Stream}             readStream                                  The read stream.
    * @param {int}                rangeStart                                  The range start.
    * @param {int}                rangeEnd                                    The range end.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         the page information.
    *                                                                         `response` will contain information related to this operation.
    */
    createPagesFromStream(container: string, blob: string, readStream: NodeJS.ReadableStream, rangeStart: number, rangeEnd: number, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Updates a page blob from a stream.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {Stream}             readStream                                  The read stream.
    * @param {int}                rangeStart                                  The range start.
    * @param {int}                rangeEnd                                    The range end.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                         the page information.
    *                                                                         `response` will contain information related to this operation.
    */
    createPagesFromStream(container: string, blob: string, readStream: NodeJS.ReadableStream, rangeStart: number, rangeEnd: number, options: BlobService.BlobTransactionOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Lists page ranges. Lists all of the page ranges by default, or only the page ranges over a specific range of bytes if rangeStart and rangeEnd are specified.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         the page ranges information, see `[Range]{@link Range}` for detailed information.
    *                                                                         `response` will contain information related to this operation.
    */
    listPageRanges(container: string, blob: string, callback: ErrorOrResult<BlobService.Range[]>): void;
    /**
    * Lists page ranges. Lists all of the page ranges by default, or only the page ranges over a specific range of bytes if rangeStart and rangeEnd are specified.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         the page ranges information, see `[Range]{@link Range}` for detailed information.
    *                                                                         `response` will contain information related to this operation.
    */
    listPageRanges(container: string, blob: string, options: BlobService.ListPageRangesOptions, callback: ErrorOrResult<BlobService.Range[]>): void;
    
    /**
    * Clears a range of pages.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {int}                rangeStart                                  The range start.
    * @param {int}                rangeEnd                                    The range end.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise 
    *                                                                         `response` will contain information related to this operation.
    */
    clearPageRange(container: string, blob: string, rangeStart: number, rangeEnd: number, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Clears a range of pages.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {int}                rangeStart                                  The range start.
    * @param {int}                rangeEnd                                    The range end.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise 
    *                                                                         `response` will contain information related to this operation.
    */
    clearPageRange(container: string, blob: string, rangeStart: number, rangeEnd: number, options: BlobService.AccessConditionsOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Resizes a page blob.
    *
    * @param {string}               container                                   The container name.
    * @param {string}               blob                                        The blob name.
    * @param {String}               size                                        The size of the page blob, in bytes.
    * @param {errorOrResult}        callback                                    `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the page information.
    *                                                                           `response` will contain information related to this operation.
    */
    resizePageBlob(container: string, blob: string, size: number, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Resizes a page blob.
    *
    * @param {string}               container                                   The container name.
    * @param {string}               blob                                        The blob name.
    * @param {String}               size                                        The size of the page blob, in bytes.
    * @param {object}               options                                     The request options.
    * @param {errorOrResult}        callback                                    `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the page information.
    *                                                                           `response` will contain information related to this operation.
    */
    resizePageBlob(container: string, blob: string, size: number, options: BlobService.AccessConditionsOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Sets the page blob's sequence number.
    *
    * @param {string}               container                                   The container name.
    * @param {string}               blob                                        The blob name.
    * @param {SequenceNumberAction} sequenceNumberAction                        A value indicating the operation to perform on the sequence number. 
    *                                                                           The allowed values are defined in azure.BlobUtilities.SequenceNumberAction.
    * @param {string}               sequenceNumber                              The sequence number.  The value of the sequence number must be between 0 and 2^63 - 1.
    *                                                                           Set this parameter to null if this operation is an increment action.
    * @param {errorOrResult}        callback                                    `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the page information.
    *                                                                           `response` will contain information related to this operation.
    */
    setPageBlobSequenceNumber(container: string, blob: string, sequenceNumberAction: string, sequenceNumber: number | string, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Sets the page blob's sequence number.
    *
    * @param {string}               container                                   The container name.
    * @param {string}               blob                                        The blob name.
    * @param {SequenceNumberAction} sequenceNumberAction                        A value indicating the operation to perform on the sequence number. 
    *                                                                           The allowed values are defined in azure.BlobUtilities.SequenceNumberAction.
    * @param {string}               sequenceNumber                              The sequence number.  The value of the sequence number must be between 0 and 2^63 - 1.
    *                                                                           Set this parameter to null if this operation is an increment action.
    * @param {object}               options                                     The request options.
    * @param {errorOrResult}        callback                                    `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the page information.
    *                                                                           `response` will contain information related to this operation.
    */
    setPageBlobSequenceNumber(container: string, blob: string, sequenceNumberAction: string, sequenceNumber: number | string, options: StorageServiceClient.AccessConditionsOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    
    // ***********************************************************
    // ** BLOCK BLOB METHODS
    // ***********************************************************
    
    /**
    * Creates a new block blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             localFileName                                 The local path to the file to be uploaded.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createBlockBlobFromLocalFile(container: string, blob: string, localFileName: string, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Creates a new block blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             localFileName                                 The local path to the file to be uploaded.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createBlockBlobFromLocalFile(container: string, blob: string, localFileName: string, options: BlobService.UploadBlockBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Uploads a block blob from a stream. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param (Stream)             stream                                        Stream to the data to store.
    * @param {int}                streamLength                                  The length of the stream to upload.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createBlockBlobFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Uploads a block blob from a stream. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param (Stream)             stream                                        Stream to the data to store.
    * @param {int}                streamLength                                  The length of the stream to upload.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createBlockBlobFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, options: BlobService.UploadBlockBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Uploads a block blob from a text string. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string|object}      text                                          The blob text, as a string or in a Buffer.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    */
    createBlockBlobFromText(container: string, blob: string, text: string | Buffer, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Uploads a block blob from a text string. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string|object}      text                                          The blob text, as a string or in a Buffer.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    */
    createBlockBlobFromText(container: string, blob: string, text: string | Buffer, options: BlobService.UploadBlockBlobFromTextOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Provides a stream to write to a block blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @return {Stream}
    */
    createWriteStreamToBlockBlob(container: string, blob: string): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a block blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToBlockBlob(container: string, blob: string, callback: ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a block blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @return {Stream}
    */
    createWriteStreamToBlockBlob(container: string, blob: string, options: BlobService.UploadBlockBlobOptions): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a block blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToBlockBlob(container: string, blob: string, options: BlobService.UploadBlockBlobOptions, callback: StorageServiceClient.ErrorOrResponse): NodeJS.WritableStream;
    
    /**
    * Creates a new block to be committed as part of a blob.
    *
    * @param {string}             blockId                                   The block identifier.
    * @param {string}             container                                 The container name.
    * @param {string}             blob                                      The blob name.
    * @param {Stream}             readStream                                The read stream.
    * @param {int}                streamLength                              The stream length.
    * @param {errorOrResponse}    callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise 
    *                                                                       `response` will contain information related to this operation.
    */
    createBlockFromStream(blockId: string, container: string, blob: string, readStream: NodeJS.ReadableStream, streamLength: number, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Creates a new block to be committed as part of a blob.
    *
    * @param {string}             blockId                                   The block identifier.
    * @param {string}             container                                 The container name.
    * @param {string}             blob                                      The blob name.
    * @param {Stream}             readStream                                The read stream.
    * @param {int}                streamLength                              The stream length.
    * @param {object}             options                                   The request options.
    * @param {errorOrResponse}    callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise 
    *                                                                       `response` will contain information related to this operation.
    */
    createBlockFromStream(blockId: string, container: string, blob: string, readStream: NodeJS.ReadableStream, streamLength: number, options: BlobService.BlobTransactionOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Creates a new block to be committed as part of a blob.
    *
    * @param {string}             blockId                                   The block identifier.
    * @param {string}             container                                 The container name.
    * @param {string}             blob                                      The blob name.
    * @param {string|buffer}      content                                   The block content.
    * @param {errorOrResponse}    callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise 
    *                                                                       `response` will contain information related to this operation.
    */
    createBlockFromText(blockId: string, container: string, blob: string, content: string | Buffer, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Creates a new block to be committed as part of a blob.
    *
    * @param {string}             blockId                                   The block identifier.
    * @param {string}             container                                 The container name.
    * @param {string}             blob                                      The blob name.
    * @param {string|buffer}      content                                   The block content.
    * @param {object}             options                                   The request options.
    * @param {errorOrResponse}    callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise 
    *                                                                       `response` will contain information related to this operation.
    */
    createBlockFromText(blockId: string, container: string, blob: string, content: string | Buffer, options: BlobService.BlobTransactionOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Writes a blob by specifying the list of block IDs that make up the blob.
    * In order to be written as part of a blob, a block must have been successfully written to the server in a prior
    * createBlock operation.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             blockList                                     The block identifiers.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    */
    commitBlocks(container: string, blob: string, blockList: BlobService.BlockList, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Writes a blob by specifying the list of block IDs that make up the blob.
    * In order to be written as part of a blob, a block must have been successfully written to the server in a prior
    * createBlock operation.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             blockList                                     The block identifiers.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    */
    commitBlocks(container: string, blob: string, blockList: BlobService.BlockList, options: BlobService.CreateBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Retrieves the list of blocks that have been uploaded as part of a block blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {BlockListFilter}    blocklisttype                               The type of block list to retrieve.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         the blocklist information.
    *                                                                         `response` will contain information related to this operation.
    */
    listBlocks(container: string, blob: string, blockListType: string, callback: ErrorOrResult<BlobService.BlockListResult>): void;
    /**
    * Retrieves the list of blocks that have been uploaded as part of a block blob.
    *
    * @param {string}             container                                   The container name.
    * @param {string}             blob                                        The blob name.
    * @param {BlockListFilter}    blocklisttype                               The type of block list to retrieve.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         the blocklist information.
    *                                                                         `response` will contain information related to this operation.
    */
    listBlocks(container: string, blob: string, blockListType: string, options: BlobService.BlobOptions, callback: ErrorOrResult<BlobService.BlockListResult>): void;
    
    /** Generate a random block id prefix. */
    generateBlockIdPrefix(): string;
    
    /** Get a block id according to prefix and block number. */
    getBlockId(prefix: string, number: number): string;
    
    
    // ***********************************************************
    // ** APPEND BLOB METHODS
    // ***********************************************************
    
    /**
    * Creates an empty append blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {errorOrResponse}    callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise 
    *                                                                           `response` will contain information related to this operation.
    */
    createOrReplaceAppendBlob(container: string, blob: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Creates an empty append blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @param {errorOrResponse}    callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise 
    *                                                                           `response` will contain information related to this operation.
    */
    createOrReplaceAppendBlob(container: string, blob: string, options: BlobService.CreateBlobOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Creates a new append blob from a local file. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    * If you want to append data to an already existing blob, please look at appendFromLocalFile.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             localFileName                                 The local path to the file to be uploaded.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createAppendBlobFromLocalFile(container: string, blob: string, localFileName: string, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Creates a new append blob from a local file. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    * If you want to append data to an already existing blob, please look at appendFromLocalFile.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             localFileName                                 The local path to the file to be uploaded.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createAppendBlobFromLocalFile(container: string, blob: string, localFileName: string, options: BlobService.UploadAppendBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Uploads an append blob from a stream. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    * If you want to append data to an already existing blob, please look at appendFromStream.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param (Stream)             stream                                        Stream to the data to store.
    * @param {int}                streamLength                                  The length of the stream to upload.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createAppendBlobFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Uploads an append blob from a stream. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    * If you want to append data to an already existing blob, please look at appendFromStream.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param (Stream)             stream                                        Stream to the data to store.
    * @param {int}                streamLength                                  The length of the stream to upload.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createAppendBlobFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, options: BlobService.UploadAppendBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Uploads an append blob from a text string. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    * If you want to append data to an already existing blob, please look at appendFromText.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string|object}      text                                          The blob text, as a string or in a Buffer.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    */
    createAppendBlobFromText(container: string, blob: string, text: string | Buffer, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Uploads an append blob from a text string. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    * If you want to append data to an already existing blob, please look at appendFromText.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string|object}      text                                          The blob text, as a string or in a Buffer.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    */
    createAppendBlobFromText(container: string, blob: string, text: string | Buffer, options: BlobService.UploadAppendBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Provides a stream to write to a new append blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @return {Stream}
    */
    createWriteStreamToNewAppendBlob(container: string, blob: string): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a new append blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {errorOrResponse}    callback                                      The callback function.
    * @return {Stream}
    */
    createWriteStreamToNewAppendBlob(container: string, blob: string, callback: ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a new append blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @return {Stream}
    */
    createWriteStreamToNewAppendBlob(container: string, blob: string, options: BlobService.UploadAppendBlobOptions): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a new append blob. If the blob already exists on the service, it will be overwritten.
    * To avoid overwriting and instead throw an error if the blob exists, please pass in an accessConditions parameter in the options object.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @param {errorOrResponse}    callback                                      The callback function.
    * @return {Stream}
    */
    createWriteStreamToNewAppendBlob(container: string, blob: string, options: BlobService.UploadAppendBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    
    /**
    * Provides a stream to write to an existing append blob. Assumes that the blob exists. 
    * If it does not, please create the blob using createAppendBlob before calling this method or use createWriteStreamToNewAppendBlob.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @return {Stream}
    */
    createWriteStreamToExistingAppendBlob(container: string, blob: string): NodeJS.WritableStream;
    /**
    * Provides a stream to write to an existing append blob. Assumes that the blob exists. 
    * If it does not, please create the blob using createAppendBlob before calling this method or use createWriteStreamToNewAppendBlob.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {errorOrResponse}    callback                                      The callback function.
    * @return {Stream}
    */
    createWriteStreamToExistingAppendBlob(container: string, blob: string, callback: ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    /**
    * Provides a stream to write to an existing append blob. Assumes that the blob exists. 
    * If it does not, please create the blob using createAppendBlob before calling this method or use createWriteStreamToNewAppendBlob.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @return {Stream}
    */
    createWriteStreamToExistingAppendBlob(container: string, blob: string, options: BlobService.UploadAppendBlobOptions): NodeJS.WritableStream;
    /**
    * Provides a stream to write to an existing append blob. Assumes that the blob exists. 
    * If it does not, please create the blob using createAppendBlob before calling this method or use createWriteStreamToNewAppendBlob.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {object}             options                                       The request options.
    * @param {errorOrResponse}    callback                                      The callback function.
    * @return {Stream}
    */
    createWriteStreamToExistingAppendBlob(container: string, blob: string, options: BlobService.UploadAppendBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): NodeJS.WritableStream;
    
    
    /**
    * Appends to an append blob from a local file. Assumes the blob already exists on the service.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             localFileName                                 The local path to the file to be uploaded.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    appendFromLocalFile(container: string, blob: string, localFileName: string, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Appends to an append blob from a local file. Assumes the blob already exists on the service.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string}             localFileName                                 The local path to the file to be uploaded.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    appendFromLocalFile(container: string, blob: string, localFileName: string, options: BlobService.UploadAppendBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Appends to an append blob from a stream. Assumes the blob already exists on the service.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param (Stream)             stream                                        Stream to the data to store.
    * @param {int}                streamLength                                  The length of the stream to upload.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    appendFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Appends to an append blob from a stream. Assumes the blob already exists on the service.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param (Stream)             stream                                        Stream to the data to store.
    * @param {int}                streamLength                                  The length of the stream to upload.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    appendFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, options: BlobService.UploadAppendBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Appends to an append blob from a text string. Assumes the blob already exists on the service.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string|object}      text                                          The blob text, as a string or in a Buffer.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    */
    appendFromText(container: string, blob: string, text: string | Buffer, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    /**
    * Appends to an append blob from a text string. Assumes the blob already exists on the service.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                     The container name.
    * @param {string}             blob                                          The blob name.
    * @param {string|object}      text                                          The blob text, as a string or in a Buffer.
    * @param {object}             options                                       The request options.
    * @param {errorOrResult}      callback                                      `error` will contain information
    *                                                                           if an error occurs; otherwise `[result]{@link BlobResult}` will contain
    *                                                                           the blob information.
    *                                                                           `response` will contain information related to this operation.
    */
    appendFromText(container: string, blob: string, text: string | Buffer, options: BlobService.UploadAppendBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): SpeedSummary;
    
    /**
    * Creates a new block from a read stream to be appended to an append blob.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                 The container name.
    * @param {string}             blob                                      The blob name.
    * @param {Stream}             readStream                                The read stream.
    * @param {int}                streamLength                              The stream length.
    * @param {errorOrResponse}    callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise 
    *                                                                       `response` will contain information related to this operation.
    */
    appendBlockFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Creates a new block from a read stream to be appended to an append blob.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @param {string}             container                                 The container name.
    * @param {string}             blob                                      The blob name.
    * @param {Stream}             readStream                                The read stream.
    * @param {int}                streamLength                              The stream length.
    * @param {object}             options                                   The request options.
    * @param {errorOrResponse}    callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise 
    *                                                                       `response` will contain information related to this operation.
    */
    appendBlockFromStream(container: string, blob: string, stream: NodeJS.ReadableStream, streamLength: number, options: BlobService.AppendBlockBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
    
    /**
    * Creates a new block from a text to be appended to an append blob.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @this {BlobService}
    * @param {string}             container                                 The container name.
    * @param {string}             blob                                      The blob name.
    * @param {string|object}      content                                   The block text, as a string or in a Buffer.
    * @param {errorOrResponse}    callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise 
    *                                                                       `response` will contain information related to this operation.
    */
    appendBlockFromText(container: string, blob: string, content: string | Buffer, callback: ErrorOrResult<BlobService.BlobResult>): void;
    /**
    * Creates a new block from a text to be appended to an append blob.
    * This API should be used strictly in a single writer scenario because the API internally uses the append-offset conditional header to avoid duplicate blocks.
    * If you are guaranteed to have a single writer scenario, please look at options.absorbConditionalErrorsOnRetry and see if setting this flag to true is acceptable for you.
    *
    * @this {BlobService}
    * @param {string}             container                                 The container name.
    * @param {string}             blob                                      The blob name.
    * @param {string|object}      content                                   The block text, as a string or in a Buffer.
    * @param {object}             options                                   The request options.
    * @param {errorOrResponse}    callback                                  `error` will contain information
    *                                                                       if an error occurs; otherwise 
    *                                                                       `response` will contain information related to this operation.
    */
    appendBlockFromText(container: string, blob: string, content: string | Buffer, options: BlobService.AppendBlockBlobOptions, callback: ErrorOrResult<BlobService.BlobResult>): void;
}

namespace BlobService {
    
    export type BlobToTextCallback  = (err: StorageError, text: string, blockBlob: BlobResult, response: StorageServiceClient.ServiceResponse) => void;
    
    // ***********************************************************
    // ** RESULTS
    // ***********************************************************
    
    export interface ContainerResult {
        /** The container name. */
        name: string;
        /** The public access level. */
        publicAccessLevel?: string;
        /** The metadata key/value pair. */
        metadata?: any;
        /** The etag. */
        etag?: string;
        /** The date/time that the container was last modified. */
        lastModified?: string;
        /** The request id. */
        requestId?: string;
        /** The lease information. */
        lease?: Lease;
        /** Does the container exists? Available after doesContainerExists call. */
        exists?: boolean;
        /** Was the container created? Available after createContainerIfNotExists call. */
        created?: boolean;
        /** The ACL Settings, available after getContainerAcl call. */
        signedIdentifiers?: StorageServiceClient.SignedIdentifiersResult;
    }
    
    export interface DirectoryResult {
        /** The directory name. */
        name: string;
        /** The metadata key/value pair. */
        metadata?: any;
        /** The etag. */
        etag?: string;
        /** The date/time that the directory was last modified. */
        lastModified?: string;
        /** The request id. */
        requestId?: string;
    }
    
    export interface BlobResult {
        /** The container name. */
        container: string;
        /** The blob name. */
        name: string;
        /** The metadata key/value pair. */
        metadata?: any;
        /** The etag. */
        etag?: string;
        /** The date/time that the blob was last modified. */
        lastModified?: string;
        /** The size of the blob in bytes. */
        contentLength?: string;
        /** The blob type. */
        blobType?: string;
        /** The request id. */
        requestId?: string;
        /** The current sequence number for a page blob. */
        sequenceNumber?: string;
        /** The content range. */
        contentRange?: string;
        
        /** Does the blob exists? Available after doesBlobExists call. */
        exists?: boolean;
        
        /** Blob's content. Available after Download calls. */
        blob?: any;
        
        /** The blob snapshot. Available if snapshots is specified in include parameter. */
        snapshot?: string;
        
        /** The content settings. */
        contentSettings?: BlobProperties;
        
        /** The lease information. */
        lease?: Lease;
        
        /** The copy information. */
        copy?: {
            /** The copy id. */
            id?: string;
            /** The copy status. */
            status?: string;
            /** The copy completion time. */
            completionTime?: string;
            /** The copy status description. */
            statusDescription?: string;
            /** The copy progress. */
            progress?: string;
            /** The copy source. */
            source?: string;
        };
        
        /** The BlockBlob BlockList. Only available after a commitBlocks call. */
        list?: BlockList;
        
        /** The AppendBlob append offset. Only available after createAppendBlobFrom call or appendFrom call. */
        appendOffset?: number;
        
        /** The AppendBlob append offset. Only available after createAppendBlobFrom call or appendFrom call. */
        committedBlockCount?: number;
    }
    
    export interface LeaseResult {
        /** The container name. */
        container: string;
        /** The blob name. */
        blob?: string;
        /** The lease id. */
        id?: string;
        /** Approximate time remaining in the lease period, in seconds. */
        time?: string;
        /** The etag. */
        etag?: string;
        /** The date/time that the lease was last modified. */
        lastModified?: string;
    }
    
    export interface BlockListResult {
        CommittedBlocks: string[];
        UncommittedBlocks: string[];
    }
    
    export interface BlobProperties {
        /** The content type. */
        contentType?: string;
        /** The content encoding. */
        contentEncoding?: string;
        /** The content language. */
        contentLanguage?: string;
        /** The cache control. */
        cacheControl?: string;
        /** The content disposition. */
        contentDisposition?: string;
        /** The content MD5 hash. */
        contentMD5?: string;
    }
    
    export interface Lease {
        /** The lease id. */
        id?: string;
        /** The lease status. */
        status: string;
        /** The lease state. */
        state: string;
        /** The lease duration. */
        duration: string;
    }
    
    export interface Range {
        start: number;
        end: number;
    }
    
    export interface BlockList {
        CommittedBlocks?: string[];
        UncommittedBlocks?: string[];
        LatestBlocks?: string[];
    }
    
    // ***********************************************************
    // ** OPTIONS
    // ***********************************************************
    
    export interface LeaseOptions extends StorageServiceClient.ServiceClientOptions {
        /** The resource lease identifier. */
        leaseId?: string;
    }
    
    export interface AccessConditionsOptions extends LeaseOptions {
        accessConditions?: AccessCondition.AccessConditions;
    }
    
    export interface ListContainerOptions extends StorageServiceClient.ServiceClientOptions {
        /** Specifies the maximum number of containers to return per call to Azure storage. */
        maxResults?: number;
        /** 
         * Include this parameter to specify that the container's metadata be returned as part of the response body. (allowed values: '', 'metadata').
         * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
         */
        include?: string;
        
        /** Filters the results to return only containers whose name begins with the specified prefix. */
        prefix?: string;
    }
    
    export interface ContainerOptions extends StorageServiceClient.ServiceClientOptions {
        /** The metadata key/value pairs. */
        metadata?: Object;
        /** Specifies whether data in the container may be accessed publicly and the level of access. */
        publicAccessLevel?: string;
    }
    
    export interface SetContainerAclOptions extends AccessConditionsOptions {
        /** Specifies whether data in the container may be accessed publicly and the level of access. */
        publicAccessLevel?: string;
    }
    
    export interface ListBlobOptions extends StorageServiceClient.ServiceClientOptions {
        /** Specifies the maximum number of directories to return per call to Azure ServiceClient. This does NOT affect list size returned by this function. (maximum: 5000). */
        maxResults?: number;
        /** Delimiter, i.e. '/', for specifying folder hierarchy. */
        delimiter?: string;
        /**
         * Specifies that the response should include one or more of the following subsets: '', 'metadata', 'snapshots', 'uncommittedblobs', 'copy').
         * Please find these values in BlobUtilities.BlobListingDetails. Multiple values can be added separated with a comma (,).
         * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
         */
        include?: string;
    }
    
    export interface AcquireLeaseOptions extends StorageServiceClient.AccessConditionsOptions {
        /** The lease duration in seconds. A non-infinite lease can be between 15 and 60 seconds. Default is never to expire. */
        leaseDuration?: string | number;
        /** The proposed lease identifier. Must be a GUID. */
        proposedLeaseId?: string;
    } 
    
    export interface BreakLeaseOptions extends StorageServiceClient.AccessConditionsOptions {
        /**
         * The lease break period, between 0 and 60 seconds. If unspecified, a fixed-duration lease breaks after
         * the remaining lease period elapses, and an infinite lease breaks immediately.
         */
        leaseBreakPeriod?: number;
    }
    
    export interface BlobOptions extends AccessConditionsOptions {
        /** The snapshot identifier. */
        snapshotId?: string;
    }
    
    export interface DownloadBlobOptions extends BlobOptions {
        /** Return only the bytes of the blob in the specified range. */
        rangeStart?: number | string;
        /** Return only the bytes of the blob in the specified range. */
        rangeEnd?: number | string;
        /** When set to true, Calculate and send/validate content MD5 for transactions. */
        useTransactionalMD5?: boolean;
        /** When set to true, MD5 validation will be disabled when downloading blobs. */
        disableContentMD5Validation?: boolean;
    }
    
    export interface DownloadBlobToFileOptions extends DownloadBlobOptions {
        /**
         * Skip the size check to perform direct download.
         * Set the option to true for small blobs.
         * Parallel download and speed summary won't work with this option on.
         */
        skipSizeCheck?: boolean;
        /** The download tracker objects. */
        speedSummary?: SpeedSummary;
        /** Parallel operation thread count */
        parallelOperationThreadCount?: number;
    }
    
    export interface DeleteBlobOptions extends BlobOptions {
        /** The snapshot delete option. See azure.BlobUtilities.SnapshotDeleteOptions.*. */
        deleteSnapshots?: string;
    }
    
    export interface BlobSnapshotOptions extends BlobOptions {
        /** The metadata key/value pairs. */
        metadata?: Object;
    }
    
    export interface CopyBlobOptions extends StorageServiceClient.ServiceClientOptions {
        /** The source blob snapshot identifier. */
        snapshotId?: string;
        /** The target blob metadata key/value pairs. */
        metadata?: Object;
        /** The target blob lease identifier. */
        leaseId?: string;
        /** The source blob lease identifier. */
        sourceLeaseId?: string;
        /** The target access conditions. */
        accessConditions?: AccessCondition.AccessConditions;
        /** The source access conditions. */
        sourceAccessConditions?: AccessCondition.AccessConditions;
    }
    
    export interface AccessPolicyHeaders {
        /** The optional value of the Cache-Control response header to be returned when this SAS is used. */
        cacheControl?: string;
        /** The optional value of the Content-Type response header to be returned when this SAS is used. */
        contentType?: string;
        /** The optional value of the Content-Encoding response header to be returned when this SAS is used. */
        contentEncoding?: string;
        /** The optional value of the Content-Language response header to be returned when this SAS is used. */
        contentLanguage?: string;
        /** The optional value of the Content-Disposition response header to be returned when this SAS is used. */
        contentDisposition?: string;
    }
    
    export interface CreateBlobOptions extends AccessConditionsOptions {
        /** The metadata key/value pairs. */
        metadata?: Object;
        /** The content settings of the blob. */
        contentSettings?: BlobProperties;
        /** The blob's sequence number. */
        sequenceNumber?: string;
    }
    
    export interface UploadBlobOptions extends AccessConditionsOptions {
        /** The upload tracker objects. */
        speedSummary?: SpeedSummary;
        /** Parallel operation thread count. */
        parallelOperationThreadCount?: number;
        /** An MD5 hash of the blob content. This hash is used to verify the integrity of the blob during transport. */
        transactionalContentMD5?: string;
        /** The metadata key/value pairs. */
        metadata?: Object;
        /** The metadata key/value pairs. */
        storeBlobContentMD5?: boolean;
        /** 
         * Specifies whether the blob's ContentMD5 header should be set on uploads.
         * The default value is false for page blobs.
         * The default value is true for block blobs.
         */
        useTransactionalMD5?: boolean;
        /** The content settings of the blob. */
        contentSettings?: BlobProperties;
    }
    
    export interface UploadBlockBlobOptions extends UploadBlobOptions {
        /** The prefix to be used to generate the block id. */
        blockIdPrefix?: string;
    }
    
    export interface BlobTransactionOptions extends AccessConditionsOptions {
        /** Calculate and send/validate content MD5 for transactions. */
        useTransactionalMD5?: boolean;
        /** An optional hash value used to ensure transactional integrity for the page. */
        transactionalContentMD5?: string;
    }
    
    export interface ListPageRangesOptions extends BlobOptions {
        /** The range start. */
        rangeStart?: number;
        /** The range end. */
        rangeEnd?: number;
    }
    
    export interface UploadBlockBlobFromTextOptions extends CreateBlobOptions {
        /** Calculate and send/validate content MD5 for transactions. */
        useTransactionalMD5?: boolean;
        /** Specifies whether the blob's ContentMD5 header should be set on uploads. The default value is true for block blobs. */
        storeBlobContentMD5?: boolean;
        /** An optional hash value used to ensure transactional integrity for the page. */
        transactionalContentMD5?: string;
    }
    
    export interface UploadAppendBlobOptions extends AccessConditionsOptions {
        /** The upload tracker objects. */
        speedSummary?: SpeedSummary;
        /** Specifies whether to absorb the conditional error on retry. */
        absorbConditionalErrorsOnRetry?: boolean;
        /** The metadata key/value pairs. */
        metadata?: Object;
        /** Specifies whether the blob's ContentMD5 header should be set on uploads. */
        storeBlobContentMD5?: boolean;
        /** Calculate and send/validate content MD5 for transactions. */
        useTransactionalMD5?: boolean;
        /** The content settings of the blob. */
        contentSettings?: BlobProperties;
    }
    
    export interface AppendBlockBlobOptions extends AccessConditionsOptions {
        /** Specifies whether to absorb the conditional error on retry. */
        absorbConditionalErrorsOnRetry?: boolean;
        /** The max length in bytes allowed for the append blob to grow to. */
        maxBlobSize?: number;
        /** The number indicating the byte offset to check for. The append will succeed only if the end position of the blob is equal to this number. */
        appendPosition?: number;
        /** An MD5 hash of the block content. This hash is used to verify the integrity of the block during transport. */
        transactionalContentMD5?: string;
    }
}

export = BlobService;
}
declare module 'azure-storage/lib/services/blob/blobservice' {
import main = require('~azure-storage/lib/services/blob/blobservice');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/blob/blobutilities.d.ts
declare module '~azure-storage/lib/services/blob/blobutilities' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* Defines constants, enums, and utility functions for use with the Blob service.
* @namespace BlobUtilities
*/

/**
* Permission types
*
* @const
* @enum {string}
*/
export const SharedAccessPermissions: {
    /**
    * @const
    * @default "a"
    */
    ADD: string;
    /**
    * @const
    * @default "r"
    */
    READ: string;
    /**
    * @const
    * @default "w"
    */
    WRITE: string;
    /**
    * @const
    * @default "d"
    */
    DELETE: string;
    /**
    * @const
    * @default "l"
    */
    LIST: string;
};

/**
* Blob listing details.
*
* @const
* @enum {string}
*/
export const BlobListingDetails: {
    /**
    * @const
    * @default "snapshots"
    */
    SNAPSHOTS: string;
    /**
    * @const
    * @default "metadata"
    */
    METADATA: string;
    /**
    * @const
    * @default "uncommittedblobs"
    */
    UNCOMMITTED_BLOBS: string;
    /**
    * @const
    * @default "copy"
    */
    COPY: string;
};

/**
* Deletion options for blob snapshots
*
* @const
* @enum {string}
*/
export const SnapshotDeleteOptions: {
    /**
    * @const
    * @default "only"
    */
    SNAPSHOTS_ONLY: string;
    /**
    * @const
    * @default "include"
    */
    BLOB_AND_SNAPSHOTS: string;
};

/**
* Type of block list to retrieve
*
* @const
* @enum {string}
*/
export const BlockListFilter: {
    /**
    * @const
    * @default "all"
    */
    ALL: string;
    /**
    * @const
    * @default "committed"
    */
    COMMITTED: string;
    /**
    * @const
    * @default "uncommitted"
    */
    UNCOMMITTED: string;
};

/**
* Blobs and container public access types.
*
* @const
* @enum {string}
*/
export const BlobContainerPublicAccessType: {
    /**
    * @const
    * @default null
    */
    OFF: any;
    /**
    * @const
    * @default "container"
    */
    CONTAINER: string;
    /**
    * @const
    * @default "blob"
    */
    BLOB: string;
};

/**
* Describes actions that can be performed on a page blob sequence number.
* @const
* @enum
*/
export const SequenceNumberAction: {
    /**
    * @const
    * @default "max"
    */
    MAX: string;
    /**
    * @const
    * @default "update"
    */
    UPDATE: string;
    /**
    * @const
    * @default "increment"
    */
    INCREMENT: string;
};
}
declare module 'azure-storage/lib/services/blob/blobutilities' {
export * from '~azure-storage/lib/services/blob/blobutilities';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/file/fileservice.d.ts
declare module '~azure-storage/lib/services/file/fileservice' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

import { StorageServiceClient, SpeedSummary, AccessCondition } from '~azure-storage/lib/common/common';
import { StorageError } from '~azure-storage/lib/common/errors/errors';

type ErrorOrResult<T> = StorageServiceClient.ErrorOrResult<T>;
type ErrorOrList<T> = StorageServiceClient.ErrorOrList<T>;

/**
* @class
* @extends {StorageServiceClient}
* The FileService class is used to perform operations on the Microsoft Azure File Service.
* The File Service provides storage for binary large objects, and provides functions for working with data stored in files.
* 
* For more information on the File Service, as well as task focused information on using it in a Node.js application, see
* [How to Use the File Service from Node.js](http://azure.microsoft.com/en-us/documentation/articles/storage-nodejs-how-to-use-file-storage/).
*/
class FileService extends StorageServiceClient {
    /** The default maximum size, in bytes, of a file before it must be separated into blocks. */
    singleFileThresholdInBytes: number;
    /** The default timeout interval, in milliseconds, to use for request made via the File service. */
    defaultTimeoutIntervalInMs: number;
    /** The default maximum execution time across all potential retries, for requests made via the File service. */
    defaultMaximumExecutionTimeInMs: number;
    /** The default location mode for requests made via the File service. */
    defaultLocationMode: number;
    /** The number of parallel operations that may be performed when uploading a file. */
    parallelOperationThreadCount: number;
    /**
     * Determines whether the Nagle algorithm is used for requests made via the File service; true to use the Nagle algorithm; otherwise, false. 
     * The default value is false.
     */
    useNagleAlgorithm: boolean;
    
    
    // ***********************************************************
    // ** STATIC
    // ***********************************************************
    
    static SpeedSummary: typeof SpeedSummary;
    
    
    /**
    * Creates a new FileService object using the AZURE_STORAGE_CONNECTION_STRING or AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY environment variables.
    * @constructor
    */
    constructor();
    /**
    * Creates a new FileService object using the given connection string.
    *
    * @constructor
    * @param {string} connectionString                    The storage account or the connection string.
    */    
    constructor(connectionString: string);
    /**
    * Creates a new FileService object using the given parameters.
    *
    * @constructor
    * @param {string} [storageAccount]                    The storage account.
    * @param {string} [storageAccessKey]                  The storage access key.
    * @param {string|object} [host]                       The host address. To define primary only, pass a string. 
    *                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
    * @param {string} [sasToken]                          The Shared Access Signature token.
    */
    constructor(storageAccount: string, storageAccessKey: string, host?: StorageServiceClient.HostConfiguration, sasToken?: string);
    
    
    // ***********************************************************
    // ** SERVICE METHODS
    // ***********************************************************
    
    /**
    * Gets the service stats for a storage account’s File service.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ServiceStats}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getServiceStats(callback: ErrorOrResult<StorageServiceClient.ServiceStats>): void;
    /**
    * Gets the service stats for a storage account’s File service.
    * @param {object}         options                               The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ServiceStats}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getServiceStats(options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<StorageServiceClient.ServiceStats>): void;
    
    
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getServiceProperties(callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {object}       options                                 The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getServiceProperties(options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    
    
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {ServiceOptions}     options                                  The request options.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    
    // ***********************************************************
    // ** SHARE METHODS
    // ***********************************************************
    
    /**
    * Lists a segment containing a collection of share items under the specified account.
    *
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[shares]{@link ShareResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listSharesSegmented(currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<FileService.ShareResult>): void;
    /**
    * Lists a segment containing a collection of share items under the specified account.
    *
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[shares]{@link ShareResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listSharesSegmented(currentToken: StorageServiceClient.ContinuationToken, options: FileService.ListSharesOptions, callback: ErrorOrList<FileService.ShareResult>): void;
    
    /**
    * Lists a segment containing a collection of share items under the specified account.
    *
    * @param {string}             prefix                                      The prefix of the share name.
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[shares]{@link ShareResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listSharesSegmentedWithPrefix(prefix: string, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<FileService.ShareResult>): void;
    /**
    * Lists a segment containing a collection of share items under the specified account.
    *
    * @param {string}             prefix                                      The prefix of the share name.
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[shares]{@link ShareResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listSharesSegmentedWithPrefix(prefix: string, currentToken: StorageServiceClient.ContinuationToken, options: FileService.ListSharesOptions, callback: ErrorOrList<FileService.ShareResult>): void;
    
    /**
    * Checks whether or not a share exists on the service.
    *
    * @param {string}             share                               The share name.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                     the share information including `exists` boolean member. 
    *                                                                     `response` will contain information related to this operation.
    */
    doesShareExist(share: string, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Checks whether or not a share exists on the service.
    *
    * @param {string}             share                               The share name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                     the share information including `exists` boolean member. 
    *                                                                     `response` will contain information related to this operation.
    */
    doesShareExist(share: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Creates a new share under the specified account.
    * If a share with the same name already exists, the operation fails.
    *
    * @param {string}             share                               The share name.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 the share information.
    *                                                                 `response` will contain information related to this operation.
    */
    createShare(share: string, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Creates a new share under the specified account.
    * If a share with the same name already exists, the operation fails.
    *
    * @param {string}             share                               The share name.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 the share information.
    *                                                                 `response` will contain information related to this operation.
    */
    createShare(share: string, options: FileService.CreateShareOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Creates a new share under the specified account if the share does not exists.
    *
    * @param {string}             share                               The share name.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 the share information.
    *                                                                 `response` will contain information related to this operation.
    */
    createShareIfNotExists(share: string, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Creates a new share under the specified account if the share does not exists.
    *
    * @param {string}             share                               The share name.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 the share information.
    *                                                                 `response` will contain information related to this operation.
    */
    createShareIfNotExists(share: string, options: FileService.CreateShareOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Retrieves a share and its properties from a specified account.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                               The share name.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 information for the share.
    *                                                                 `response` will contain information related to this operation.
    */
    getShareProperties(share: string, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Retrieves a share and its properties from a specified account.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                               The share name.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 information for the share.
    *                                                                 `response` will contain information related to this operation.
    */
    getShareProperties(share: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Sets the properties for the specified share.
    *
    * @param {string}             share                               The share name.
    * @param {object}             [properties]                        The share properties to set.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 information for the share.
    *                                                                 `response` will contain information related to this operation.
    */
    setShareProperties(share: string, properties: FileService.ShareProperties, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Sets the properties for the specified share.
    *
    * @param {string}             share                               The share name.
    * @param {object}             [properties]                        The share properties to set.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 information for the share.
    *                                                                 `response` will contain information related to this operation.
    */
    setShareProperties(share: string, properties: FileService.ShareProperties, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Gets the service stats for a storage account’s File service.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ShareResult}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getShareStats(share: string, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Gets the service stats for a storage account’s File service.
    * @param {object}         options                               The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ShareResult}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getShareStats(share: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Retrieves a share and its properties from a specified account.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                               The share name.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 information for the share.
    *                                                                 `response` will contain information related to this operation.
    */
    getShareMetadata(share: string, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Retrieves a share and its properties from a specified account.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                               The share name.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 information for the share.
    *                                                                 `response` will contain information related to this operation.
    */
    getShareMetadata(share: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Sets the share's metadata.
    *
    * @param {string}             share                               The share name.
    * @param {object}             metadata                            The metadata key/value pairs.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 information for the share.
    *                                                                 `response` will contain information related to this operation.
    */
    setShareMetadata(share: string, metadata: Object, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Sets the share's metadata.
    *
    * @param {string}             share                               The share name.
    * @param {object}             metadata                            The metadata key/value pairs.
    * @param {object}             options                             The request options.
    * @param {errorOrResult}      callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                 information for the share.
    *                                                                 `response` will contain information related to this operation.
    */
    setShareMetadata(share: string, metadata: Object, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Gets the share's ACL.
    *
    * @param {string}             share                                       The share name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                         information for the share.
    *                                                                         `response` will contain information related to this operation.
    */
    getShareAcl(share: string, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Gets the share's ACL.
    *
    * @param {string}             share                                       The share name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                         information for the share.
    *                                                                         `response` will contain information related to this operation.
    */
    getShareAcl(share: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Updates the share's ACL.
    *
    * @param {string}             share                                       The share name.
    * @param {Object.<string, AccessPolicy>} signedIdentifiers                The container ACL settings. See `[AccessPolicy]{@link AccessPolicy}` for detailed information.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                         information for the share.
    *                                                                         `response` will contain information related to this operation.
    */
    setShareAcl(share: string, signedIdentifiers: StorageServiceClient.SignedIdentifiers, callback: ErrorOrResult<FileService.ShareResult>): void;
    /**
    * Updates the share's ACL.
    *
    * @param {string}             share                                       The share name.
    * @param {Object.<string, AccessPolicy>} signedIdentifiers                The container ACL settings. See `[AccessPolicy]{@link AccessPolicy}` for detailed information.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link ShareResult}` will contain
    *                                                                         information for the share.
    *                                                                         `response` will contain information related to this operation.
    */
    setShareAcl(share: string, signedIdentifiers: StorageServiceClient.SignedIdentifiers, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.ShareResult>): void;
    
    /**
    * Marks the specified share for deletion.
    * The share and any files contained within it are later deleted during garbage collection.
    *
    * @this {FileService}
    * @param {string}             share                               The share name.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteShare(share: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified share for deletion.
    * The share and any files contained within it are later deleted during garbage collection.
    *
    * @this {FileService}
    * @param {string}             share                               The share name.
    * @param {object}             options                             The request options.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteShare(share: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Marks the specified share for deletion if it exists.
    * The share and any files contained within it are later deleted during garbage collection.
    *
    * @this {FileService}
    * @param {string}             share                               The share name.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteShareIfExists(share: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified share for deletion if it exists.
    * The share and any files contained within it are later deleted during garbage collection.
    *
    * @this {FileService}
    * @param {string}             share                               The share name.
    * @param {object}             options                             The request options.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteShareIfExists(share: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    // ***********************************************************
    // ** DIRECTORY METHODS
    // ***********************************************************
    
    /**
    * Checks whether or not a directory exists on the service.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name. Use '' to refer to the base directory.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    doesDirectoryExist(share: string, directory: string, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    /**
    * Checks whether or not a directory exists on the service.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name. Use '' to refer to the base directory.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    doesDirectoryExist(share: string, directory: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    
    /**
    * Creates a new directory under the specified account.
    * If a directory with the same name already exists, the operation fails.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    createDirectory(share: string, directory: string, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    /**
    * Creates a new directory under the specified account.
    * If a directory with the same name already exists, the operation fails.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    createDirectory(share: string, directory: string, options: FileService.CreateDirectoryOptions, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    
    /**
    * Creates a new directory under the specified account if the directory does not exists.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    createDirectoryIfNotExists(share: string, directory: string, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    /**
    * Creates a new directory under the specified account if the directory does not exists.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    createDirectoryIfNotExists(share: string, directory: string, options: FileService.CreateDirectoryOptions, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    
    /**
    * Retrieves a directory and its properties from a specified account.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name. Use '' to refer to the base directory.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    getDirectoryProperties(share: string, directory: string, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    /**
    * Retrieves a directory and its properties from a specified account.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name. Use '' to refer to the base directory.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    getDirectoryProperties(share: string, directory: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    
    /**
    * Marks the specified directory for deletion. The directory must be empty before it can be deleted.
    *
    * @param {string}             share                               The share name.
    * @param {string}             directory                           The directory name.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteDirectory(share: string, directory: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified directory for deletion. The directory must be empty before it can be deleted.
    *
    * @param {string}             share                               The share name.
    * @param {string}             directory                           The directory name.
    * @param {object}             options                             The request options.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteDirectory(share: string, directory: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Marks the specified directory for deletion if it exists. The directory must be empty before it can be deleted.
    *
    * @param {string}             share                               The share name.
    * @param {string}             directory                           The directory name.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteDirectoryIfExists(share: string, directory: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified directory for deletion if it exists. The directory must be empty before it can be deleted.
    *
    * @param {string}             share                               The share name.
    * @param {string}             directory                           The directory name.
    * @param {object}             options                             The request options.
    * @param {errorOrResponse}    callback                            `error` will contain information
    *                                                                 if an error occurs; otherwise
    *                                                                 `response` will contain information related to this operation.
    */
    deleteDirectoryIfExists(share: string, directory: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Lists a segment containing a collection of file items in the directory.
    *
    * @param {string}             share                             The share name.
    * @param {string}             directory                         The directory name. Use '' to refer to the base directory.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain
    *                                                               entries.files which contains a list of `[files]{@link FileResult}`, entries.directories which contains a list of `[directories]{@link DirectoryResult}` and the continuationToken for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listFilesAndDirectoriesSegmented(share: string, directory: string, currentToken: FileService.ListOptions, callback: ErrorOrResult<FileService.DirectoryListResult>): void;
    /**
    * Lists a segment containing a collection of file items in the directory.
    *
    * @param {string}             share                             The share name.
    * @param {string}             directory                         The directory name. Use '' to refer to the base directory.
    * @param {object}             currentToken                      A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                           The request options.
    * @param {errorOrResult}      callback                          `error` will contain information
    *                                                               if an error occurs; otherwise `result` will contain
    *                                                               entries.files which contains a list of `[files]{@link FileResult}`, entries.directories which contains a list of `[directories]{@link DirectoryResult}` and the continuationToken for the next listing operation.
    *                                                               `response` will contain information related to this operation.
    */
    listFilesAndDirectoriesSegmented(share: string, directory: string, currentToken: FileService.ListOptions, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.DirectoryListResult>): void;
    
    /**
    * Returns all user-defined metadata for the specified directory.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name. Use '' to refer to the base directory.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    getDirectoryMetadata(share: string, directory: string, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    /**
    * Returns all user-defined metadata for the specified directory.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name. Use '' to refer to the base directory.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    getDirectoryMetadata(share: string, directory: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    
    /**
    * Sets user-defined metadata for the specified directory as one or more name-value pairs 
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name. Use '' to refer to the base directory.
    * @param {object}             metadata                                The metadata key/value pairs.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    setDirectoryMetadata(share: string, directory: string, metadata: Object, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    /**
    * Sets user-defined metadata for the specified directory as one or more name-value pairs 
    *
    * @param {string}             share                                   The share name.
    * @param {string}             directory                               The directory name. Use '' to refer to the base directory.
    * @param {object}             metadata                                The metadata key/value pairs.
    * @param {object}             options                                 The request options.
    * @param {errorOrResult}      callback                                `error` will contain information
    *                                                                     if an error occurs; otherwise `[result]{@link DirectoryResult}` will contain
    *                                                                     the directory information including `exists` boolean member.
    *                                                                     `response` will contain information related to this operation.
    */
    setDirectoryMetadata(share: string, directory: string, metadata: Object, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.DirectoryResult>): void;
    
    // ***********************************************************
    // ** FILE METHODS
    // ***********************************************************
    
    /**
    * Retrieves a shared access signature token.
    *
    * @param {string}                   share                                               The share name.
    * @param {string}                   [directory]                                         The directory name. Use '' to refer to the base directory.
    * @param {string}                   [file]                                              The file name.
    * @param {object}                   sharedAccessPolicy                                  The shared access policy.
    * @param {object}                   [headers]                                           The optional header values to set for a file returned wth this SAS.
    * @return {string}                                                                      The shared access signature query string. Note this string does not contain the leading "?".
    */
    generateSharedAccessSignature(share: string, directory: string, file: string, sharedAccessPolicy: StorageServiceClient.SharedAccessPolicy, headers?: FileService.AccessPolicyHeaders): string;
    
    /**
    * Retrieves a file or directory URL.
    *
    * @param {string}                   share                    The share name.
    * @param {string}                   directory                The directory name. Use '' to refer to the base directory.
    * @param {string}                   [file]                   The file name. File names may not start or end with the delimiter '/'.
    * @param {string}                   [sasToken]               The Shared Access Signature token.
    * @param {boolean}                  [primary]                A boolean representing whether to use the primary or the secondary endpoint.
    * @return {string}                                           The formatted URL string.
    */
    getUrl(share: string, directory: string, file?: string, sasToken?: string, primary?: boolean): string
    
    /**
    * Returns all user-defined metadata, standard HTTP properties, and system properties for the file.
    * It does not return or modify the content of the file.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    getFileProperties(share: string, directory: string, file: string, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Returns all user-defined metadata, standard HTTP properties, and system properties for the file.
    * It does not return or modify the content of the file.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    getFileProperties(share: string, directory: string, file: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Returns all user-defined metadata for the specified file.
    * It does not modify or return the content of the file.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    getFileMetadata(share: string, directory: string, file: string, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Returns all user-defined metadata for the specified file.
    * It does not modify or return the content of the file.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    getFileMetadata(share: string, directory: string, file: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Sets user-defined properties for the specified file.
    * It does not modify or return the content of the file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             [properties]                                The file properties to set.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    setFileProperties(share: string, directory: string, file: string, properties: FileService.FileProperties, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Sets user-defined properties for the specified file.
    * It does not modify or return the content of the file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             [properties]                                The file properties to set.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    setFileProperties(share: string, directory: string, file: string, properties: FileService.FileProperties, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Sets user-defined metadata for the specified file as one or more name-value pairs 
    * It does not modify or return the content of the file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             metadata                                    The metadata key/value pairs.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    setFileMetadata(share: string, directory: string, file: string, metadata: Object, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Sets user-defined metadata for the specified file as one or more name-value pairs 
    * It does not modify or return the content of the file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             metadata                                    The metadata key/value pairs.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    setFileMetadata(share: string, directory: string, file: string, metadata: Object, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Resizes a file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {String}             size                                        The size of the file, in bytes.
    * @param {object}             metadata                                    The metadata key/value pairs.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    resizeFile(share: string, directory: string, file: string, size: string | number, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Resizes a file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {String}             size                                        The size of the file, in bytes.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    resizeFile(share: string, directory: string, file: string, size: string | number, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Checks whether or not a file exists on the service.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information including the `exists` boolean member. 
    *                                                                         `response` will contain information related to this operation.
    */
    doesFileExist(share: string, directory: string, file: string, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Checks whether or not a file exists on the service.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information including the `exists` boolean member. 
    *                                                                         `response` will contain information related to this operation.
    */
    doesFileExist(share: string, directory: string, file: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Creates a file of the specified length. If the file already exists on the service, it will be overwritten.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {int}                length                                      The length of the file in bytes.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    createFile(share: string, directory: string, file: string, length: number, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Creates a file of the specified length. If the file already exists on the service, it will be overwritten.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {int}                length                                      The length of the file in bytes.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    createFile(share: string, directory: string, file: string, length: number, options: FileService.CreateFileOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Marks the specified file for deletion. The file is later deleted during garbage collection.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; `response` will contain information related to this operation.
    */
    deleteFile(share: string, directory: string, file: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified file for deletion. The file is later deleted during garbage collection.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; `response` will contain information related to this operation.
    */
    deleteFile(share: string, directory: string, file: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Marks the specified file for deletion if it exists. The file is later deleted during garbage collection.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; `response` will contain information related to this operation.
    */
    deleteFileIfExists(share: string, directory: string, file: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Marks the specified file for deletion if it exists. The file is later deleted during garbage collection.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; `response` will contain information related to this operation.
    */
    deleteFileIfExists(share: string, directory: string, file: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Downloads a file into a text string.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {FileService~FileToText}  callback                               `error` will contain information
    *                                                                         if an error occurs; otherwise `text` will contain the file contents,
    *                                                                         and `[file]{@link FileResult}` will contain the file information.
    *                                                                         `response` will contain information related to this operation.
    */
    getFileToText(share: string, directory: string, file: string, callback: FileService.FileToText): void;
    /**
    * Downloads a file into a text string.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {FileService~FileToText}  callback                               `error` will contain information
    *                                                                         if an error occurs; otherwise `text` will contain the file contents,
    *                                                                         and `[file]{@link FileResult}` will contain the file information.
    *                                                                         `response` will contain information related to this operation.
    */
    getFileToText(share: string, directory: string, file: string, options: FileService.DownloadFileOptions, callback: FileService.FileToText): void;
    
    /**
    * Downloads an Azure file into a file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             localFileName                               The local path to the file to be downloaded.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    getFileToLocalFile(share: string, directory: string, file: string, localFileName: string, callback: ErrorOrResult<FileService.FileResult>): SpeedSummary;
    /**
    * Downloads an Azure file into a file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             localFileName                               The local path to the file to be downloaded.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    getFileToLocalFile(share: string, directory: string, file: string, localFileName: string, options: FileService.DownloadSpeedFileOptions, callback: ErrorOrResult<FileService.FileResult>): SpeedSummary;
    
    /**
    * Provides a stream to read from a file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @return {Stream}
    */
    createReadStream(share: string, directory: string, file: string): NodeJS.ReadableStream;
    /**
    * Provides a stream to read from a file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @return {Stream}
    */
    createReadStream(share: string, directory: string, file: string, options: FileService.DownloadFileOptions): NodeJS.ReadableStream;
    /**
    * Provides a stream to read from a file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    createReadStream(share: string, directory: string, file: string, callback: ErrorOrResult<FileService.FileResult>): NodeJS.ReadableStream;
    /**
    * Provides a stream to read from a file.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    createReadStream(share: string, directory: string, file: string, options: FileService.DownloadFileOptions, callback: ErrorOrResult<FileService.FileResult>): NodeJS.ReadableStream;
    
    /**
    * Downloads a file into a stream.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {Stream}             writeStream                                 The write stream.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    getFileToStream(share: string, directory: string, file: string, writeStream: NodeJS.WritableStream, callback: ErrorOrResult<FileService.FileResult>): SpeedSummary;
    /**
    * Downloads a file into a stream.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {Stream}             writeStream                                 The write stream.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    getFileToStream(share: string, directory: string, file: string, writeStream: NodeJS.WritableStream, options: FileService.DownloadSpeedFileOptions, callback: ErrorOrResult<FileService.FileResult>): SpeedSummary;
    
    /**
    * Lists All file ranges.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the range information.
    *                                                                         `response` will contain information related to this operation.
    */
    listRanges(share: string, directory: string, file: string, callback: ErrorOrResult<FileService.Range[]>): void;
    /**
    * Lists file ranges. Lists all of the ranges by default, or only the ranges over a specific range of bytes if rangeStart and rangeEnd are specified.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the range information.
    *                                                                         `response` will contain information related to this operation.
    */
    listRanges(share: string, directory: string, file: string, options: FileService.ListFileRangesOptions, callback: ErrorOrResult<FileService.Range[]>): void;
    
    /**
    * Clears a range. Clears all of the ranges by default, or only the ranges over a specific range of bytes if rangeStart and rangeEnd are specified.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {int}                rangeStart                                  The range start.
    * @param {int}                rangeEnd                                    The range end.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    clearRange(share: string, directory: string, file: string, rangeStart: number, rangeEnd: number, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Clears a range. Clears all of the ranges by default, or only the ranges over a specific range of bytes if rangeStart and rangeEnd are specified.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {int}                rangeStart                                  The range start.
    * @param {int}                rangeEnd                                    The range end.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    clearRange(share: string, directory: string, file: string, rangeStart: number, rangeEnd: number, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Updates a range from a stream.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {Stream}             readStream                                  The read stream.
    * @param {int}                rangeStart                                  The range start.
    * @param {int}                rangeEnd                                    The range end.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    createRangesFromStream(share: string, directory: string, file: string, readStream: NodeJS.ReadableStream, rangeStart: number, rangeEnd: number, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Updates a range from a stream.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {Stream}             readStream                                  The read stream.
    * @param {int}                rangeStart                                  The range start.
    * @param {int}                rangeEnd                                    The range end.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    createRangesFromStream(share: string, directory: string, file: string, readStream: NodeJS.ReadableStream, rangeStart: number, rangeEnd: number, options: FileService.UpdateFileRangeOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Uploads a file from a text string. If the file already exists on the service, it will be overwritten.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {Stream}             text                                        The file text, as a string or in a Buffer.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    createFileFromText(share: string, directory: string, file: string, text: string | Buffer, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Uploads a file from a text string. If the file already exists on the service, it will be overwritten.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {Stream}             text                                        The file text, as a string or in a Buffer.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    createFileFromText(share: string, directory: string, file: string, text: string | Buffer, options: FileService.UploadFileOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Uploads a file to storage from a local file. If the file already exists on the service, it will be overwritten.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             localFileName                               The local path to the file to be downloaded.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createFileFromLocalFile(share: string, directory: string, file: string, localFileName: string, callback: ErrorOrResult<FileService.FileResult>): SpeedSummary;
    /**
    * Uploads a file to storage from a local file. If the file already exists on the service, it will be overwritten.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             localFileName                               The local path to the file to be downloaded.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createFileFromLocalFile(share: string, directory: string, file: string, localFileName: string, options: FileService.UploadFileOptions, callback: ErrorOrResult<FileService.FileResult>): SpeedSummary;
    
    /**
    * Uploads a file from a stream. If the file already exists on the service, it will be overwritten.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param (Stream)             stream                                      Stream to the data to store.
    * @param {int}                streamLength                                The length of the stream to upload.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createFileFromStream(share: string, directory: string, file: string, stream: NodeJS.ReadableStream, streamLength: number, callback: ErrorOrResult<FileService.FileResult>): SpeedSummary;
    /**
    * Uploads a file from a stream. If the file already exists on the service, it will be overwritten.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param (Stream)             stream                                      Stream to the data to store.
    * @param {int}                streamLength                                The length of the stream to upload.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {SpeedSummary}
    */
    createFileFromStream(share: string, directory: string, file: string, stream: NodeJS.ReadableStream, streamLength: number, options: FileService.UploadFileOptions, callback: ErrorOrResult<FileService.FileResult>): SpeedSummary;
    
    /**
    * Provides a stream to write to a file. Assumes that the file exists. 
    * If it does not, please create the file using createFile before calling this method or use createWriteStreamNewFile.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @return {Stream}
    */
    createWriteStreamToExistingFile(share: string, directory: string, file: string): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a file. Assumes that the file exists. 
    * If it does not, please create the file using createFile before calling this method or use createWriteStreamNewFile.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @return {Stream}
    */
    createWriteStreamToExistingFile(share: string, directory: string, file: string, options: FileService.UploadFileOptions): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a file. Assumes that the file exists. 
    * If it does not, please create the file using createFile before calling this method or use createWriteStreamNewFile.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToExistingFile(share: string, directory: string, file: string, callback: ErrorOrResult<FileService.FileResult>): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a file. Assumes that the file exists. 
    * If it does not, please create the file using createFile before calling this method or use createWriteStreamNewFile.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToExistingFile(share: string, directory: string, file: string, options: FileService.UploadFileOptions, callback: ErrorOrResult<FileService.FileResult>): NodeJS.WritableStream;
    
    /**
    * Provides a stream to write to a file. Creates the file before writing data.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             length                                      The file length.
    * @return {Stream}
    */
    createWriteStreamToNewFile(share: string, directory: string, file: string, length: number): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a file. Creates the file before writing data.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             length                                      The file length.
    * @param {object}             options                                     The request options.
    * @return {Stream}
    */
    createWriteStreamToNewFile(share: string, directory: string, file: string, length: number, options: FileService.UploadFileOptions): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a file. Creates the file before writing data.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             length                                      The file length.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToNewFile(share: string, directory: string, file: string, length: number, callback: ErrorOrResult<FileService.FileResult>): NodeJS.WritableStream;
    /**
    * Provides a stream to write to a file. Creates the file before writing data.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             length                                      The file length.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information. 
    *                                                                         `response` will contain information related to this operation.
    * @return {Stream}
    */
    createWriteStreamToNewFile(share: string, directory: string, file: string, length: number, options: FileService.UploadFileOptions, callback: ErrorOrResult<FileService.FileResult>): NodeJS.WritableStream;
    
    /**
    * Starts to copy a file to a destination within the storage account.
    *
    * @param {string}             sourceUri                                   The source file or blob URI.
    * @param {string}             targetShare                                 The target share name.
    * @param {string}             targetDirectory                             The target directory name.
    * @param {string}             targetFile                                  The target file name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information including the `exists` boolean member. 
    *                                                                         `response` will contain information related to this operation.
    */
    startCopyFile(sourceUri: string, targetShare: string, targetDirectory: string, targetFile: string, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Starts to copy a file to a destination within the storage account.
    *
    * @param {string}             sourceUri                                   The source file or blob URI.
    * @param {string}             targetShare                                 The target share name.
    * @param {string}             targetDirectory                             The target directory name.
    * @param {string}             targetFile                                  The target file name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         the file information including the `exists` boolean member. 
    *                                                                         `response` will contain information related to this operation.
    */
    startCopyFile(sourceUri: string, targetShare: string, targetDirectory: string, targetFile: string, options: FileService.StartCopyOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
    /**
    * Abort a file copy operation.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             copyId                                      The copy operation identifier.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    abortCopyFile(share: string, directory: string, file: string, copyId: string, callback: ErrorOrResult<FileService.FileResult>): void;
    /**
    * Abort a file copy operation.
    *
    * @param {string}             share                                       The share name.
    * @param {string}             directory                                   The directory name. Use '' to refer to the base directory.
    * @param {string}             file                                        The file name. File names may not start or end with the delimiter '/'.
    * @param {string}             copyId                                      The copy operation identifier.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link FileResult}` will contain
    *                                                                         information about the file.
    *                                                                         `response` will contain information related to this operation.
    */
    abortCopyFile(share: string, directory: string, file: string, copyId: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<FileService.FileResult>): void;
    
}

namespace FileService {
    
    export type FileToText = (err: StorageError, text: string, file: FileResult, response: StorageServiceClient.ServiceResponse) => void;
    
    // ***********************************************************
    // ** RESULTS
    // ***********************************************************
    
    export interface ShareResult {
        /** The share name. */
        name: string;
        /** The metadata key/value pair. */
        metadata?: any;
        /** The etag. */
        etag?: string;
        /** The date/time that the share was last modified. */
        lastModified?: string;
        /** The request id. */
        requestId?: string;
        /** The share quota. */
        quota?: number;
        /** The signed identifiers. Only available after a getShareAcl call. */
        signedIdentifiers?: StorageServiceClient.SignedIdentifiersResult;
        /** The share public access level. Only available after a getShareAcl call. */
        publicAccessLevel?: string;
        /** The share statistics. Only available after a getShareStats call. */
        shareStats?: ShareStats;
        /** Does the share exist? Only available after a doesShareExist call. */
        exists?: boolean;
        /** Was the share created? Only available after a createShareIfNotExists call. */
        created?: boolean;
    }
    
    export interface DirectoryResult {
        /** The directory name. */
        name: string;
        /** The metadata key/value pair. */
        metadata?: any;
        /** The etag.  */
        etag?: string;
        /** The date/time that the directory was last modified. */
        lastModified?: string;
        /** The request id. */
        requestId?: string;
        /** Does the directory exist? Only available after a doesDirectoryExist call. */
        exists?: boolean;
        /** Was the directory created? Only available after a createDirectoryIfNotExists call. */
        created?: boolean;
    }
    
    export interface FileResult {
        /** The share name. */
        share: string;
        /** The directory name. */
        directory: string;
        /** The file name. */
        name: string;
        /** The metadata key/value pair. */
        metadata?: any;
        /** The etag.  */
        etag?: string;
        /** The date/time that the file was last modified. */
        lastModified?: string;
        /** The request id. */
        requestId?: string;
        
        /** The accept ranges. */
        acceptRanges?: string;
        /** The content range. */
        contentRange?: string;
        /** The size of the file in bytes.. */
        contentLength?: string;
        /** The content settings. */
        contentSettings?: FileProperties;
        
        /** The copy information. */
        copy?: {
            /** The copy id. */
            id: string;
            /** The copy status. */
            status: string;
            /** The copy completion time. */
            completionTime: string;
            /** The copy status description. */
            statusDescription: string;
            /** The copy progress. */
            progress: string;
            /** The copy source. */
            source: string;
        };
        
        /** Does the file exist? Only available after a doesFileExist call. */
        exists?: boolean;
    }
    
    export interface DirectoryListResult {
        entries: {
            files: FileResult[];
            directories: DirectoryResult[];
        };
        
        continuationToken?: StorageServiceClient.ContinuationToken;
    }
    
    export interface ShareProperties {
        /** Specifies the maximum size of the share, in gigabytes. */
        quota?: number | string;
    }
    
    export interface ShareStats {
        /**  */
        shareUsage?: number;
    }
    
    export interface FileProperties {
        /** The content type. */
        contentType?: string;
        /** The content encoding. */
        contentEncoding?: string;
        /** The content language. */
        contentLanguage?: string;
        /** The cache control. */
        cacheControl?: string;
        /** The content disposition. */
        contentDisposition?: string;
        /** The content MD5 hash. */
        contentMD5?: string;
    }
    
    export interface Range {
        start: number;
        end: number;
    }
    
    
    // ***********************************************************
    // ** OPTIONS
    // ***********************************************************
    
    export interface ListSharesOptions extends StorageServiceClient.ServiceClientOptions {
        /** Specifies the maximum number of shares to return per call to Azure storage. */
        maxResults?: number;
        /** 
         * Include this parameter to specify that the share's metadata be returned as part of the response body. (allowed values: '', 'metadata').
         * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
         */
        include?: string;
        /** Filters the results to return only shares whose name begins with the specified prefix. */
        prefix?: string;
    }
    
    export interface CreateShareOptions extends StorageServiceClient.ServiceClientOptions {
        /** Specifies the maximum size of the share, in gigabytes. */
        quota?: number;
        /** The metadata key/value pairs. */
        metadata?: Object;
    }
    
    export interface CreateDirectoryOptions extends StorageServiceClient.ServiceClientOptions {
        /** The metadata key/value pairs. */
        metadata?: Object;
    }
    
    export interface ListOptions extends StorageServiceClient.ServiceClientOptions {
        /** Specifies the maximum number of files to return per call to Azure ServiceClient. This does NOT affect list size returned by this function. (maximum: 5000) */
        maxResults?: number;
    }
    
    export interface AccessPolicyHeaders {
        /** The optional value of the Cache-Control response header to be returned when this SAS is used. */
        cacheControl?: string;
        /** The optional value of the Content-Type response header to be returned when this SAS is used. */
        contentType?: string;
        /** The optional value of the Content-Encoding response header to be returned when this SAS is used. */
        contentEncoding?: string;
        /** The optional value of the Content-Language response header to be returned when this SAS is used. */
        contentLanguage?: string;
        /** The optional value of the Content-Disposition response header to be returned when this SAS is used. */
        contentDisposition?: string;
    }
    
    export interface CreateFileOptions extends StorageServiceClient.ServiceClientOptions {
        /** The file's content settings. */
        contentSettings?: FileProperties;
        /** The metadata key/value pairs. */
        metadata?: Object;
    }
    
    export interface DownloadFileOptions extends StorageServiceClient.ServiceClientOptions {
        /** The range start. */
        rangeStart?: number;
        /** The range end. */
        rangeEnd?: number;
        /** When set to true, MD5 validation will be disabled when downloading files. */
        disableContentMD5Validation?: boolean;
    }
    
    export interface DownloadSpeedFileOptions extends DownloadFileOptions {
        /**
         * Skip the size check to perform direct download.
         * Set the option to true for small files.
         * Parallel download and speed summary won't work with this option on.
         */
        skipSizeCheck?: boolean;
        /** The download tracker objects. */
        speedSummary?: SpeedSummary;
        /** When set to true, Calculate and send/validate content MD5 for transactions. */
        useTransactionalMD5?: boolean;
    }
    
    export interface ListFileRangesOptions extends StorageServiceClient.ServiceClientOptions {
        /** The range start. */
        rangeStart?: number;
        /** The range end. */
        rangeEnd?: number;
    }
    
    export interface UpdateFileRangeOptions extends StorageServiceClient.ServiceClientOptions {
        /** Calculate and send/validate content MD5 for transactions. */
        useTransactionalMD5?: boolean;
        /** An optional hash value used to ensure transactional integrity for the page. */
        transactionalContentMD5?: string;
    }
    
    export interface UploadFileOptions extends CreateFileOptions {
        /** The upload tracker objects. */
        speedSummary?: SpeedSummary;
        /** 
         * Specifies whether the file's ContentMD5 header should be set on uploads.
         * The default value is false for files.
         */
        storeFileContentMD5?: boolean;
        /** Calculate and send/validate content MD5 for transactions. */
        useTransactionalMD5?: boolean;
    }
    
    export interface StartCopyOptions extends StorageServiceClient.ServiceClientOptions {
        /** The target file metadata key/value pairs. */
        metadata?: Object;
        /** The source access conditions. */
        accessConditions?: AccessCondition.AccessConditions
        /** The source access conditions. */
        sourceAccessConditions?: AccessCondition.AccessConditions
    }
}

export = FileService;
}
declare module 'azure-storage/lib/services/file/fileservice' {
import main = require('~azure-storage/lib/services/file/fileservice');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/file/fileutilities.d.ts
declare module '~azure-storage/lib/services/file/fileutilities' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* Defines constants, enums, and utility functions for use with the File service.
* @namespace FileUtilities
*/

/**
* Permission types
*
* @const
* @enum {string}
*/
export const SharedAccessPermissions: {
    /**
    * @const
    * @default "r"
    */
    READ: string;
    /**
    * @const
    * @default "w"
    */
    WRITE: string;
    /**
    * @const
    * @default "d"
    */
    DELETE: string;
    /**
    * @const
    * @default "l"
    */
    LIST: string;
};

/**
* Listing details.
*
* @const
* @enum {string}
*/
export const ListingDetails: {
    /**
    * @const
    * @default "metadata"
    */
    METADATA: string;
};

/**
* File and share public access types.
*
* @const
* @enum {string}
*/
export const SharePublicAccessType: {
    /**
    * @const
    * @default null
    */
    OFF: any;
    /**
    * @const
    * @default "share"
    */
    SHARE: string;
    /**
    * @const
    * @default "file"
    */
    FILE: string;
};
}
declare module 'azure-storage/lib/services/file/fileutilities' {
export * from '~azure-storage/lib/services/file/fileutilities';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/queue/queueservice.d.ts
declare module '~azure-storage/lib/services/queue/queueservice' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

import { StorageServiceClient } from '~azure-storage/lib/common/common';

type ErrorOrResult<T> = StorageServiceClient.ErrorOrResult<T>;
type ErrorOrList<T> = StorageServiceClient.ErrorOrList<T>;

/**
* @class
* @extends {StorageServiceClient}
* The QueueService class is used to perform operations on the Microsoft Azure Queue Service.
* 
* For more information on using the Queue Service, as well as task focused information on using it from a Node.js application, see
* [How to Use the Queue Service from Node.js](http://azure.microsoft.com/en-us/documentation/articles/storage-nodejs-how-to-use-queues/).
*/
class QueueService extends StorageServiceClient {
    /** A flag indicating whether the message should be base-64 encoded. Default is true. */
    encodeMessage: boolean;
    /** The default timeout interval, in milliseconds, to use for request made via the Queue service. */
    defaultTimeoutIntervalInMs: number;
    /** The default maximum execution time across all potential retries, for requests made via the Queue service. */
    defaultMaximumExecutionTimeInMs: number;
    /** The default location mode for requests made via the Queue service. */
    defaultLocationMode: number;
    /**
     * Determines whether the Nagle algorithm is used for requests made via the Blob service; true to use the Nagle algorithm; otherwise, false. 
     * The default value is false.
     */
    useNagleAlgorithm: boolean;
    
    
    /**
    * Creates a new QueueService object using the AZURE_STORAGE_CONNECTION_STRING or AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY environment variables.
    * @constructor
    */
    constructor();
    /**
    * Creates a new QueueService object using the given connection string.
    *
    * @constructor
    * @param {string} connectionString                    The storage account or the connection string.
    */    
    constructor(connectionString: string);
    /**
    * Creates a new QueueService object using the given parameters.
    *
    * @constructor
    * @param {string} [storageAccount]                    The storage account.
    * @param {string} [storageAccessKey]                  The storage access key.
    * @param {string|object} [host]                       The host address. To define primary only, pass a string. 
    *                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
    * @param {string} [sasToken]                          The Shared Access Signature token.
    */
    constructor(storageAccount: string, storageAccessKey: string, host?: StorageServiceClient.HostConfiguration, sasToken?: string);
    
    
    // ***********************************************************
    // ** SERVICE METHODS
    // ***********************************************************
    
    /**
    * Gets the service stats for a storage account’s Queue service.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ServiceStats}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getServiceStats(callback: ErrorOrResult<StorageServiceClient.ServiceStats>): void;
    /**
    * Gets the service stats for a storage account’s Queue service.
    * @param {object}         options                               The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `[result]{@link ServiceStats}` will contain the stats and 
    *                                                               `response` will contain information related to this operation.
    */
    getServiceStats(options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<StorageServiceClient.ServiceStats>): void;
    
    
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getServiceProperties(callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    /**
    * Gets the properties of a storage account’s service, including Azure Storage Analytics.
    * @param {object}       options                                 The request options.
    * @param {errorOrResult}  callback                              `error` will contain information if an error occurs; otherwise, `result` will contain the properties 
    *                                                               and `response` will contain information related to this operation.
    */
    getServiceProperties(options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResult<StorageServiceClient.ServiceProperties>): void;
    
    
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {ServiceOptions}     options                                  The request options.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Sets the properties of a storage account’s service, including Azure Storage Analytics.
    * You can also use this operation to set the default request version for all incoming requests that do not have a version specified.
    *
    * @param {ServiceProperties}  serviceProperties                        The service properties.
    * @param {errorOrResponse}    callback                                 `error` will contain information
    *                                                                      if an error occurs; otherwise, `response`
    *                                                                      will contain information related to this operation.
    */
    setServiceProperties(serviceProperties: StorageServiceClient.ServiceProperties, options: StorageServiceClient.ServiceOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    
    // ***********************************************************
    // ** LIST QUEUE METHODS
    // ***********************************************************
    
    /**
    * Lists a segment containing a collection of queue items whose names begin with the specified prefix under the given account.
    *
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[queues]{@link QueueResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listQueuesSegmented(currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<QueueService.QueueResult>): void;
    /**
    * Lists a segment containing a collection of queue items whose names begin with the specified prefix under the given account.
    *
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[queues]{@link QueueResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listQueuesSegmented(currentToken: StorageServiceClient.ContinuationToken, options: QueueService.ListQueueOptions, callback: ErrorOrList<QueueService.QueueResult>): void;
    
    /**
    * Lists a segment containing a collection of queue items  under the given account.
    *
    * @param {string}             prefix                                      The prefix of the queue name.
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[queues]{@link QueueResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listQueuesSegmentedWithPrefix(prefix: string, currentToken: StorageServiceClient.ContinuationToken, callback: ErrorOrList<QueueService.QueueResult>): void;
    /**
    * Lists a segment containing a collection of queue items  under the given account.
    *
    * @param {string}             prefix                                      The prefix of the queue name.
    * @param {object}             currentToken                                A continuation token returned by a previous listing operation. Please use 'null' or 'undefined' if this is the first operation.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain `entries` and `continuationToken`. 
    *                                                                         `entries`  gives a list of `[queues]{@link QueueResult}` and the `continuationToken` is used for the next listing operation.
    *                                                                         `response` will contain information related to this operation.
    */
    listQueuesSegmentedWithPrefix(prefix: string, currentToken: StorageServiceClient.ContinuationToken, options: QueueService.ListQueueOptions, callback: ErrorOrList<QueueService.QueueResult>): void;
    
    
    // ***********************************************************
    // ** QUEUE METHODS
    // ***********************************************************
    
    /**
    * Checks to see if a queue exists.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise, `[result]{@link QueueResult}` will contain
    *                                                                         the queue information including `exists` boolean member.
    *                                                                         `response` will contain information related to this operation.
    */
    doesQueueExist(queue: string, callback: ErrorOrResult<QueueService.QueueResult>): void;
    /**
    * Checks to see if a queue exists.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise, `[result]{@link QueueResult}` will contain
    *                                                                         the queue information including `exists` boolean member.
    *                                                                         `response` will contain information related to this operation.
    */
    doesQueueExist(queue: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<QueueService.QueueResult>): void;
    
    /**
    * Creates a new queue under the given account.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         the queue information.
    *                                                                         `response` will contain information related to this operation.
    */
    createQueue(queue: string, callback: ErrorOrResult<QueueService.QueueResult>): void;
    /**
    * Creates a new queue under the given account.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         the queue information.
    *                                                                         `response` will contain information related to this operation.
    */
    createQueue(queue: string, options: QueueService.CreateQueueOptions, callback: ErrorOrResult<QueueService.QueueResult>): void;
    
    /**
    * Creates a new queue under the given account if it doesn't exist.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         the queue information.
    *                                                                         `response` will contain information related to this operation.
    */
    createQueueIfNotExists(queue: string, callback: ErrorOrResult<QueueService.QueueResult>): void;
    /**
    * Creates a new queue under the given account if it doesn't exist.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         the queue information.
    *                                                                         `response` will contain information related to this operation.
    */
    createQueueIfNotExists(queue: string, options: QueueService.CreateQueueOptions, callback: ErrorOrResult<QueueService.QueueResult>): void;
    
    /**
    * Permanently deletes the specified queue.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResponse}    callback                                    `error` will contain information if an error occurs; 
    *                                                                         `response` will contain information related to this operation.
    */
    deleteQueue(queue: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Permanently deletes the specified queue.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information if an error occurs; 
    *                                                                         `response` will contain information related to this operation.
    */
    deleteQueue(queue: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Permanently deletes the specified queue if it exists.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResponse}    callback                                    `error` will contain information if an error occurs; 
    *                                                                         `response` will contain information related to this operation.
    */
    deleteQueueIfExists(queue: string, callback: ErrorOrResult<boolean>): void;
    /**
    * Permanently deletes the specified queue if it exists.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information if an error occurs; 
    *                                                                         `response` will contain information related to this operation.
    */
    deleteQueueIfExists(queue: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<boolean>): void;
    
    /**
    * Returns queue properties, including user-defined metadata.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         the queue information.
    *                                                                         `response` will contain information related to this operation.
    */
    getQueueMetadata(queue: string, callback: ErrorOrResult<QueueService.QueueResult>): void;
    /**
    * Returns queue properties, including user-defined metadata.
    * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         the queue information.
    *                                                                         `response` will contain information related to this operation.
    */
    getQueueMetadata(queue: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<QueueService.QueueResult>): void;
    
    /**
    * Sets user-defined metadata on the specified queue. Metadata is associated with the queue as name-value pairs.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             metadata                                    The metadata key/value pairs.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         the queue information.
    *                                                                         `response` will contain information related to this operation.
    */
    setQueueMetadata(queue: string, metadata: Object, callback: ErrorOrResult<QueueService.QueueResult>): void;
    /**
    * Sets user-defined metadata on the specified queue. Metadata is associated with the queue as name-value pairs.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             metadata                                    The metadata key/value pairs.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         the queue information.
    *                                                                         `response` will contain information related to this operation.
    */
    setQueueMetadata(queue: string, metadata: Object, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<QueueService.QueueResult>): void;
    
    
    // ***********************************************************
    // ** QUEUE MESSAGE METHODS
    // ***********************************************************
    
    /**
    * Adds a new message to the back of the message queue. 
    * The encoded message can be up to 64KB in size for versions 2011-08-18 and newer, or 8KB in size for previous versions. 
    * Unencoded messages must be in a format that can be included in an XML request with UTF-8 encoding. 
    * Queue messages are encoded by default. See queueService.encodeMessage to set encoding defaults. 
    * 
    * @param {string}             queue                                       The queue name.
    * @param {string|Buffer}      messageText                                 The message text.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `response` will contain information related to this operation.
    */
    createMessage(queue: string, messageText: string | Buffer, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Adds a new message to the back of the message queue. 
    * The encoded message can be up to 64KB in size for versions 2011-08-18 and newer, or 8KB in size for previous versions. 
    * Unencoded messages must be in a format that can be included in an XML request with UTF-8 encoding. 
    * Queue messages are encoded by default. See queueService.encodeMessage to set encoding defaults. 
    * 
    * @param {string}             queue                                       The queue name.
    * @param {string|Buffer}      messageText                                 The message text.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `response` will contain information related to this operation.
    */
    createMessage(queue: string, messageText: string | Buffer, options: QueueService.CreateMessageOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Retrieve messages from the queue and makes them invisible to other consumers.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         a list of `[messages]{@link QueueMessageResult}`.
    *                                                                         `response` will contain information related to this operation.
    */
    getMessages(queue: string, callback: ErrorOrResult<QueueService.QueueMessageResult[]>): void;
    /**
    * Retrieve messages from the queue and makes them invisible to other consumers.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         a list of `[messages]{@link QueueMessageResult}`.
    *                                                                         `response` will contain information related to this operation.
    */
    getMessages(queue: string, options: QueueService.GetMessagesOptions, callback: ErrorOrResult<QueueService.QueueMessageResult[]>): void;
    
    /**
    * Retrieves a message from the queue and makes it invisible to other consumers.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         a list of `[messages]{@link QueueMessageResult}`.
    *                                                                         `response` will contain information related to this operation.
    */
    getMessage(queue: string, callback: ErrorOrResult<QueueService.QueueMessageResult>): void;
    /**
    * Retrieves a message from the queue and makes it invisible to other consumers.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         a list of `[messages]{@link QueueMessageResult}`.
    *                                                                         `response` will contain information related to this operation.
    */
    getMessage(queue: string, options: QueueService.GetMessageOptions, callback: ErrorOrResult<QueueService.QueueMessageResult>): void;
    
    
    /**
    * Retrieves messages from the front of the queue, without changing the messages visibility.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         a list of `[messages]{@link QueueMessageResult}`.
    *                                                                         `response` will contain information related to this operation.
    */
    peekMessages(queue: string, callback: ErrorOrResult<QueueService.QueueMessageResult[]>): void;
    /**
    * Retrieves messages from the front of the queue, without changing the messages visibility.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         a list of `[messages]{@link QueueMessageResult}`.
    *                                                                         `response` will contain information related to this operation.
    */
    peekMessages(queue: string, options: QueueService.PeekMessagesOptions, callback: ErrorOrResult<QueueService.QueueMessageResult[]>): void;
    
    /**
    * Retrieves a message from the front of the queue, without changing the message visibility.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         a list of `[messages]{@link QueueMessageResult}`.
    *                                                                         `response` will contain information related to this operation.
    */
    peekMessage(queue: string, callback: ErrorOrResult<QueueService.QueueMessageResult>): void;
    /**
    * Retrieves a message from the front of the queue, without changing the message visibility.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `result` will contain
    *                                                                         a list of `[messages]{@link QueueMessageResult}`.
    *                                                                         `response` will contain information related to this operation.
    */
    peekMessage(queue: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<QueueService.QueueMessageResult>): void;
    
    /**
    * Deletes a specified message from the queue.
    *
    * @param {string}             queue                                       The queue name.
    * @param {string}             messageId                                   The message identifier of the message to delete.
    * @param {string}             popReceipt                                  A valid pop receipt value returned from an earlier call to the Get Messages or Update Message operation
    * @param {errorOrResponse}    callback                                    `error` will contain information if an error occurs; 
    *                                                                         `response` will contain information related to this operation.
    */
    deleteMessage(queue: string, messageId: string, popReceipt: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Deletes a specified message from the queue.
    *
    * @param {string}             queue                                       The queue name.
    * @param {string}             messageId                                   The message identifier of the message to delete.
    * @param {string}             popReceipt                                  A valid pop receipt value returned from an earlier call to the Get Messages or Update Message operation
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information if an error occurs; 
    *                                                                         `response` will contain information related to this operation.
    */
    deleteMessage(queue: string, messageId: string, popReceipt: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Clears all messages from the queue.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise 
    *                                                                         `response` will contain information related to this operation.
    */
    clearMessages(queue: string, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Clears all messages from the queue.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResponse}    callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise 
    *                                                                         `response` will contain information related to this operation.
    */
    clearMessages(queue: string, options: StorageServiceClient.ServiceClientOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    /**
    * Updates the visibility timeout of a message. You can also use this operation to update the contents of a message.
    * A message must be in a format that can be included in an XML request with UTF-8 encoding, and the encoded message can be up to 64KB in size.
    *
    * @param {string}             queue                                       The queue name.
    * @param {string}             messageId                                   The message identifier of the message to update.
    * @param {string}             popReceipt                                  A valid pop receipt value returned from an earlier call to the Get Messages or Update Message operation
    * @param {int}                visibilityTimeout                           Specifies the new visibility timeout value, in seconds, relative to server time. The new value must be larger than or 
    *                                                                         equal to 0, and cannot be larger than 7 days. The visibility timeout of a message can be set to a value later than 
    *                                                                         the expiry time.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueMessageResult}` will contain
    *                                                                         the message result information.
    *                                                                         `response` will contain information related to this operation.
    */
    updateMessage(queue: string, messageId: string, popReceipt: string, visibilityTimeout: number, callback: StorageServiceClient.ErrorOrResponse): void;
    /**
    * Updates the visibility timeout of a message. You can also use this operation to update the contents of a message.
    * A message must be in a format that can be included in an XML request with UTF-8 encoding, and the encoded message can be up to 64KB in size.
    *
    * @param {string}             queue                                       The queue name.
    * @param {string}             messageId                                   The message identifier of the message to update.
    * @param {string}             popReceipt                                  A valid pop receipt value returned from an earlier call to the Get Messages or Update Message operation
    * @param {int}                visibilityTimeout                           Specifies the new visibility timeout value, in seconds, relative to server time. The new value must be larger than or 
    *                                                                         equal to 0, and cannot be larger than 7 days. The visibility timeout of a message can be set to a value later than 
    *                                                                         the expiry time.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueMessageResult}` will contain
    *                                                                         the message result information.
    *                                                                         `response` will contain information related to this operation.
    */
    updateMessage(queue: string, messageId: string, popReceipt: string, visibilityTimeout: number, options: QueueService.UpdateMessageOptions, callback: StorageServiceClient.ErrorOrResponse): void;
    
    
    // ***********************************************************
    // ** QUEUE ACL METHODS
    // ***********************************************************
    
    /**
    * Gets the queue's ACL.
    *
    * @param {string}             queue                                       The queue name.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         information for the queue.
    *                                                                         `response` will contain information related to this operation.
    */
    getQueueAcl(queue: string, callback: ErrorOrResult<QueueService.QueueResult>): void;
    /**
    * Gets the queue's ACL.
    *
    * @param {string}             queue                                       The queue name.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         information for the queue.
    *                                                                         `response` will contain information related to this operation.
    */
    getQueueAcl(queue: string, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<QueueService.QueueResult>): void;
    
    /**
    * Updates the queue's ACL.
    *
    * @param {string}             queue                                       The queue name.
    * @param {Object.<string, AccessPolicy>} signedIdentifiers                The container ACL settings. See `[AccessPolicy]{@link AccessPolicy}` for detailed information.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         information for the queue.
    *                                                                         `response` will contain information related to this operation.
    */
    setQueueAcl(queue: string, signedIdentifiers: StorageServiceClient.SignedIdentifiers, callback: ErrorOrResult<QueueService.QueueResult>): void;
    /**
    * Updates the queue's ACL.
    *
    * @param {string}             queue                                       The queue name.
    * @param {Object.<string, AccessPolicy>} signedIdentifiers                The container ACL settings. See `[AccessPolicy]{@link AccessPolicy}` for detailed information.
    * @param {object}             options                                     The request options.
    * @param {errorOrResult}      callback                                    `error` will contain information
    *                                                                         if an error occurs; otherwise `[result]{@link QueueResult}` will contain
    *                                                                         information for the queue.
    *                                                                         `response` will contain information related to this operation.
    */
    setQueueAcl(queue: string, signedIdentifiers: StorageServiceClient.SignedIdentifiers, options: StorageServiceClient.ServiceClientOptions, callback: ErrorOrResult<QueueService.QueueResult>): void;
    
    
    /**
    * Retrieves a shared access signature token.
    *
    * @param {string}                   queue                                               The queue name.
    * @param {object}                   sharedAccessPolicy                                  The shared access policy.
    * @return {string}                                                                      The shared access signature query string. Note this string does not contain the leading "?".
    */
    generateSharedAccessSignature(queue: string, sharedAccessPolicy: StorageServiceClient.SharedAccessPolicy): string;
}

namespace QueueService {
    
    // ***********************************************************
    // ** RESULTS
    // ***********************************************************
    
    export interface QueueResult {
        /** The queue name. */
        name: string;
        /** The metadata key/value pair. */
        metadata?: any;
        /** The approximate number of messages in the queue. This number is not lower than the actual number of messages in the queue, but could be higher. */
        approximateMessageCount?: number;
        /** The container ACL settings. See AccessPolicy for detailed information. */
        signedIdentifiers?: StorageServiceClient.SignedIdentifiersResult;
        /** Does the queue exists? Available after a doesQueueExist call. */
        exists?: boolean;
        /** Was queue created ? Available after a createQueueIfNotExists call. */
        created?: boolean;
    }
    
    export interface QueueMessageResult {
        /** The queue name. */
        name: string;
        /** The message id. */
        messageId?: string;
        /** The pop receipt. */
        popReceipt?: string;
        /** The message text. */
        messageText?: string;
        /** The time next visible. */
        timeNextVisible?: string;
        /** The insertion time. */
        insertionTime?: string;
        /** The expiration time. */
        expirationTime?: string;
        /** The dequeue count. */
        dequeueCount?: string;
    }
    
    // ***********************************************************
    // ** OPTIONS
    // ***********************************************************
    
    export interface ListQueueOptions extends StorageServiceClient.ServiceClientOptions {
        /** Specifies the maximum number of queues to return per call to Azure storage. This does NOT affect list size returned by this function. (maximum: 5000) */
        maxResults?: number;
        /** 
         * Include this parameter to specify that the queue's metadata be returned as part of the response body. (allowed values: '', 'metadata').
         * **Note** that all metadata names returned from the server will be converted to lower case by NodeJS itself as metadata is set via HTTP headers and HTTP header names are case insensitive.
         */
        include?: string;
    }
    
    export interface CreateQueueOptions extends StorageServiceClient.ServiceClientOptions {
        /** The metadata key/value pairs. */
        metadata?: Object;
    }
    
    export interface CreateMessageOptions extends GetMessageOptions {
        /** The time-to-live interval for the message, in seconds. The maximum time-to-live allowed is 7 days. If this parameter is omitted, the default time-to-live is 7 days */
        messageTimeToLive?: number;
    }
    
    export interface GetMessageOptions extends StorageServiceClient.ServiceClientOptions {
        /** 
         * Specifies the new visibility timeout value, in seconds, relative to server time. The new value must be larger than or equal to 0, and cannot be larger than 7 days. 
         * The visibility timeout of a message cannot be set to a value later than the expiry time. visibilitytimeout should be set to a value smaller than the time-to-live value.
         */
        visibilityTimeout?: number;
    }
    
    export interface GetMessagesOptions extends GetMessageOptions {
        /** A nonzero integer value that specifies the number of messages to retrieve from the queue, up to a maximum of 32. By default, a single message is retrieved from the queue with this operation. */
        numOfMessages?: number;
        /** 
         * Specifies the new visibility timeout value, in seconds, relative to server time. The new value must be larger than or equal to 0, and cannot be larger than 7 days. 
         * The visibility timeout of a message cannot be set to a value later than the expiry time. visibilitytimeout should be set to a value smaller than the time-to-live value.
         */
        visibilityTimeout?: number;
    }
    
    export interface PeekMessagesOptions extends StorageServiceClient.ServiceClientOptions {
        /** A nonzero integer value that specifies the number of messages to retrieve from the queue, up to a maximum of 32. By default, a single message is retrieved from the queue with this operation. */
        numOfMessages?: number;
    }
    
    export interface UpdateMessageOptions extends StorageServiceClient.ServiceClientOptions {
        /** The new message text. */
        messageText?: string;
    }
}

export = QueueService;
}
declare module 'azure-storage/lib/services/queue/queueservice' {
import main = require('~azure-storage/lib/services/queue/queueservice');
export = main;
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/services/queue/queueutilities.d.ts
declare module '~azure-storage/lib/services/queue/queueutilities' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

/**
* Defines enums for use with the Queue service.
* @namespace QueueUtilities
*/

/**
* Permission types.
*
* @const
* @enum {string}
*/
export const SharedAccessPermissions: {
    /**
    * @const
    * @default "r"
    */
    READ: string;
    /**
    * @const
    * @default "a"
    */
    ADD: string;
    /**
    * @const
    * @default "u"
    */
    UPDATE: string;
    /**
    * @const
    * @default "p"
    */
    PROCESS: string;
};
}
declare module 'azure-storage/lib/services/queue/queueutilities' {
export * from '~azure-storage/lib/services/queue/queueutilities';
}

// Generated by typings
// Source: https://raw.githubusercontent.com/typed-contrib/azure-storage-node/140f44b051ee914e350e3d777cb8a096ec9a2b94/lib/azure-storage.d.ts
declare module '~azure-storage/lib/azure-storage' {
// Type definitions for azure-storage-node v0.10.0
// Project: https://github.com/Azure/azure-storage-node
// Definitions by: Maxime LUCE <https://github.com/SomaticIT/>
// Definitions: https://github.com/typed-contrib/azure-storage-node

import { StorageServiceClient, date } from '~azure-storage/lib/common/common';

/**
* Creates a connection string that can be used to create a service which runs on the storage emulator. The emulator must be downloaded separately.
*
* @param {string}   [proxyUri]                  The proxyUri. By default, http://127.0.0.1
* @return {string}                              A connection string representing the development storage credentials.
*/
export function generateDevelopmentStorageCredentials(proxyUri?: string): string;

// ***********************************************************
// ** TABLE SERVICE
// ***********************************************************

export import TableService = require('~azure-storage/lib/services/table/tableservice');
export import TableBatch = require('~azure-storage/lib/services/table/tablebatch');
export import TableQuery = require('~azure-storage/lib/services/table/tablequery');
export import TableUtilities = require('~azure-storage/lib/services/table/tableutilities');

/**
* Creates a new TableService object using AZURE_STORAGE_CONNECTION_STRING or the AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY environment variables.
*
* @return {TableService}                              A new TableService object.
*/
export function createTableService(): TableService;
/**
* Creates a new TableService object using given connection string.
*
* @param {string} [connectionString]                  The connection string.
* @return {TableService}                              A new TableService object.
*/
export function createTableService(connectionString: string): TableService;
/**
* Creates a new TableService object using storage account and storage access key.
*
* @param {string} [storageAccount]                    The storage account.
* @param {string} [storageAccessKey]                  The storage access key.
* @param {Host} [host]                                The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @return {TableService}                              A new TableService object.
*/
export function createTableService(storageAccount: string, storageAccessKey: string, host?: StorageServiceClient.HostConfiguration): TableService;

/**
* Creates a new TableService object using the host Uri and the SAS credentials provided.
* 
* @param {Host} host                                  The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @param {string} sasToken                            The Shared Access Signature token.
* @return {TableService}                              A new TableService object with the SAS credentials.
*/
export function createTableServiceWithSas(hostUri: StorageServiceClient.HostConfiguration, sasToken: string): TableService;

// ***********************************************************
// ** BLOB SERVICE
// ***********************************************************

export import BlobService = require('~azure-storage/lib/services/blob/blobservice');
export import BlobUtilities = require('~azure-storage/lib/services/blob/blobutilities');

/**
* Creates a new BlobService object using AZURE_STORAGE_CONNECTION_STRING or the AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY environment variables.
*
* @return {BlobService}                               A new BlobService object.
*/
export function createBlobService(): BlobService;
/**
* Creates a new BlobService object using given connection string.
*
* @param {string} [connectionString]                  The connection string.
* @return {BlobService}                               A new BlobService object.
*/
export function createBlobService(connectionString: string): BlobService;
/**
* Creates a new BlobService object using storage account and storage access key.
*
* @param {string} [storageAccount]                    The storage account.
* @param {string} [storageAccessKey]                  The storage access key.
* @param {Host} [host]                                The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @return {BlobService}                               A new BlobService object.
*/
export function createBlobService(storageAccount: string, storageAccessKey: string, host?: StorageServiceClient.HostConfiguration): BlobService;

/**
* Creates a new BlobService object using the host Uri and the SAS credentials provided.
* 
* @param {Host} host                                  The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @param {string} sasToken                            The Shared Access Signature token.
* @return {BlobService}                               A new BlobService object with the SAS credentials.
*/
export function createBlobServiceWithSas(hostUri: StorageServiceClient.HostConfiguration, sasToken: string): BlobService;

/**
* Creates a new BlobService object using the host uri and anonymous access.
* 
* @param {Host} host                                  The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @return {BlobService}                               A new BlobService object with the anonymous credentials.
*/
export function createBlobServiceAnonymous(host: StorageServiceClient.HostConfiguration): BlobService;

// ***********************************************************
// ** FILE SERVICE
// ***********************************************************

export import FileService = require('~azure-storage/lib/services/file/fileservice');
export import FileUtilities = require('~azure-storage/lib/services/file/fileutilities');

/**
* Creates a new FileService object using AZURE_STORAGE_CONNECTION_STRING or the AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY environment variables.
*
* @return {FileService}                               A new FileService object.
*/
export function createFileService(): FileService;
/**
* Creates a new FileService object using given connection string.
*
* @param {string} [connectionString]                  The connection string.
* @return {FileService}                               A new FileService object.
*/
export function createFileService(connectionString: string): FileService;
/**
* Creates a new FileService object using storage account and storage access key.
*
* @param {string} [storageAccount]                    The storage account.
* @param {string} [storageAccessKey]                  The storage access key.
* @param {Host} [host]                                The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @return {FileService}                               A new FileService object.
*/
export function createFileService(storageAccount: string, storageAccessKey: string, host?: StorageServiceClient.HostConfiguration): FileService;

/**
* Creates a new FileService object using the host Uri and the SAS credentials provided.
* 
* @param {Host} host                                  The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @param {string} sasToken                            The Shared Access Signature token.
* @return {FileService}                               A new FileService object with the SAS credentials.
*/
export function createFileServiceWithSas(hostUri: StorageServiceClient.HostConfiguration, sasToken: string): FileService;

// ***********************************************************
// ** QUEUE SERVICE
// ***********************************************************

export import QueueService = require('~azure-storage/lib/services/queue/queueservice');
export import QueueUtilities = require('~azure-storage/lib/services/queue/queueutilities');

/**
* Creates a new QueueService object using AZURE_STORAGE_CONNECTION_STRING or the AZURE_STORAGE_ACCOUNT and AZURE_STORAGE_ACCESS_KEY environment variables.
*
* @return {QueueService}                               A new QueueService object.
*/
export function createQueueService(): QueueService;
/**
* Creates a new QueueService object using given connection string.
*
* @param {string} [connectionString]                  The connection string.
* @return {QueueService}                               A new QueueService object.
*/
export function createQueueService(connectionString: string): QueueService;
/**
* Creates a new QueueService object using storage account and storage access key.
*
* @param {string} [storageAccount]                    The storage account.
* @param {string} [storageAccessKey]                  The storage access key.
* @param {Host} [host]                                The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @return {QueueService}                               A new QueueService object.
*/
export function createQueueService(storageAccount: string, storageAccessKey: string, host?: StorageServiceClient.HostConfiguration): QueueService;

/**
* Creates a new QueueService object using the host Uri and the SAS credentials provided.
* 
* @param {Host} host                                  The host address. To define primary only, pass a string. 
*                                                     Otherwise 'host.primaryHost' defines the primary host and 'host.secondaryHost' defines the secondary host.
* @param {string} sasToken                            The Shared Access Signature token.
* @return {QueueService}                               A new QueueService object with the SAS credentials.
*/
export function createQueueServiceWithSas(hostUri: StorageServiceClient.HostConfiguration, sasToken: string): QueueService;

// ***********************************************************
// ** COMMON EXPORTS
// ***********************************************************

export interface AccountSharedAccessPolicy {
    AccessPolicy: AccountAccessPolicy;
}

export interface AccountAccessPolicy extends StorageServiceClient.AccessPolicy {
    /**
     * The services (blob, file, queue, table) for a shared access signature associated with this shared access policy.
     * Refer to `Constants.AccountSasConstants.Services`.
     */
    Services: string;
    
    /** 
     * The resource type for a shared access signature associated with this shared access policy.
     * Refer to `Constants.AccountSasConstants.ResourceTypes`.
     */
    ResourceTypes: string;
}

/**
* Generates an account shared access signature token
* 
* @param {string}                     [storageAccountOrConnectionString]                The storage account or the connection string.
* @param {string}                     [storageAccessKey]                                The storage access key.
* @param {object}                     sharedAccessPolicy                                The shared access policy.
*/
export function generateAccountSharedAccessSignature(storageAccountOrConnectionString: string, storageAccessKey: string, sharedAccessAccountPolicy: AccountSharedAccessPolicy): string;

export {
    Constants,
    StorageUtilities,
    AccessCondition,
    
    SR,
    StorageServiceClient,
    Logger,
    WebResource,
    validate as Validate,
    date,
    
    LinearRetryPolicyFilter,
    ExponentialRetryPolicyFilter,
    RetryPolicyFilter
} from '~azure-storage/lib/common/common';

/*
 * TYPE REEXPORT
 */
export { TableEntity, EntityProperty } from '~azure-storage/lib/services/table/tableservice';
export type SignedIdentifiers = StorageServiceClient.SignedIdentifiers;
}
declare module 'azure-storage/lib/azure-storage' {
export * from '~azure-storage/lib/azure-storage';
}
declare module 'azure-storage' {
export * from '~azure-storage/lib/azure-storage';
}
