@azure/ms-rest-js

  • Version 2.6.0
  • Published
  • 2.29 MB
  • 9 dependencies
  • MIT license

Install

npm i @azure/ms-rest-js
yarn add @azure/ms-rest-js
pnpm add @azure/ms-rest-js

Overview

Isomorphic client Runtime for Typescript/node.js/browser javascript client libraries generated using AutoRest

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable Constants

const Constants: {
msRestVersion: string;
HTTP: string;
HTTPS: string;
HTTP_PROXY: string;
HTTPS_PROXY: string;
NO_PROXY: string;
ALL_PROXY: string;
HttpConstants: {
HttpVerbs: {
PUT: string;
GET: string;
DELETE: string;
POST: string;
MERGE: string;
HEAD: string;
PATCH: string;
};
StatusCodes: { TooManyRequests: number };
};
HeaderConstants: {
AUTHORIZATION: string;
AUTHORIZATION_SCHEME: string;
RETRY_AFTER: string;
USER_AGENT: string;
};
};

    variable isNode

    const isNode: boolean;
    • A constant that indicates whether the environment is node.js or browser based.

    variable MapperType

    const MapperType: {
    Base64Url: 'Base64Url';
    Boolean: 'Boolean';
    ByteArray: 'ByteArray';
    Date: 'Date';
    DateTime: 'DateTime';
    DateTimeRfc1123: 'DateTimeRfc1123';
    Object: 'Object';
    Stream: 'Stream';
    String: 'String';
    TimeSpan: 'TimeSpan';
    UnixTime: 'UnixTime';
    Number: 'Number';
    Composite: 'Composite';
    Sequence: 'Sequence';
    Dictionary: 'Dictionary';
    Enum: 'Enum';
    };

      Functions

      function agentPolicy

      agentPolicy: (agentSettings?: AgentSettings) => RequestPolicyFactory;

        function applyMixins

        applyMixins: (targetCtor: any, sourceCtors: any[]) => void;
        • Applies the properties on the prototype of sourceCtors to the prototype of targetCtor

          Parameter targetCtor

          The target object on which the properties need to be applied.

          Parameter sourceCtors

          An array of source objects from which the properties need to be taken.

        function delay

        delay: <T>(t: number, value?: T) => Promise<T>;
        • A wrapper for setTimeout that resolves a promise after t milliseconds.

          Parameter t

          The number of milliseconds to be delayed.

          Parameter value

          The value to be resolved with after a timeout of t milliseconds.

          Returns

          {Promise} Resolved promise

        function deserializationPolicy

        deserializationPolicy: (
        deserializationContentTypes?: DeserializationContentTypes
        ) => RequestPolicyFactory;
        • Create a new serialization RequestPolicyCreator that will serialized HTTP request bodies as they pass through the HTTP pipeline.

        function deserializeResponseBody

        deserializeResponseBody: (
        jsonContentTypes: string[],
        xmlContentTypes: string[],
        response: HttpOperationResponse
        ) => Promise<HttpOperationResponse>;

          function encodeUri

          encodeUri: (uri: string) => string;
          • Encodes an URI.

            Parameter uri

            The URI to be encoded. {string} The encoded URI.

          function executePromisesSequentially

          executePromisesSequentially: (
          promiseFactories: Array<any>,
          kickstart: any
          ) => Promise<any>;
          • Executes an array of promises sequentially. Inspiration of this method is here: https://pouchdb.com/2015/05/18/we-have-a-problem-with-promises.html. An awesome blog on promises!

            Parameter promiseFactories

            An array of promise factories(A function that return a promise)

            Parameter kickstart

            Input to the first promise that is used to kickstart the promise chain. If not provided then the promise chain starts with undefined.

            A chain of resolved or rejected promises

          function exponentialRetryPolicy

          exponentialRetryPolicy: (
          retryCount?: number,
          retryInterval?: number,
          minRetryInterval?: number,
          maxRetryInterval?: number
          ) => RequestPolicyFactory;

            function flattenResponse

            flattenResponse: (
            _response: HttpOperationResponse,
            responseSpec: OperationResponse | undefined
            ) => RestResponse;

              function generateClientRequestIdPolicy

              generateClientRequestIdPolicy: (
              requestIdHeaderName?: string
              ) => RequestPolicyFactory;

                function generateUuid

                generateUuid: () => string;
                • Generated UUID

                  {string} RFC4122 v4 UUID.

                function getDefaultProxySettings

                getDefaultProxySettings: (proxyUrl?: string) => ProxySettings | undefined;

                  function getDefaultUserAgentValue

                  getDefaultUserAgentValue: () => string;

                    function isDuration

                    isDuration: (value: string) => boolean;
                    • Indicates whether the given string is in ISO 8601 format.

                      Parameter value

                      The value to be validated for ISO 8601 duration format. {boolean} true if valid, false otherwise.

                    function isValidUuid

                    isValidUuid: (uuid: string) => boolean;
                    • Validates the given uuid as a string

                      Parameter uuid

                      The uuid as a string that needs to be validated

                      {boolean} True if the uuid is valid; false otherwise.

                    function logPolicy

                    logPolicy: (logger?: any) => RequestPolicyFactory;

                      function promiseToCallback

                      promiseToCallback: (promise: Promise<any>) => Function;
                      • Converts a Promise to a callback.

                        Parameter promise

                        The Promise to be converted to a callback

                        Returns

                        {Function} A function that takes the callback (cb: Function): void

                        Deprecated

                        generated code should instead depend on responseToBody

                      function promiseToServiceCallback

                      promiseToServiceCallback: <T>(
                      promise: Promise<HttpOperationResponse>
                      ) => Function;
                      • Converts a Promise to a service callback.

                        Parameter promise

                        The Promise of HttpOperationResponse to be converted to a service callback

                        Returns

                        {Function} A function that takes the service callback (cb: ServiceCallback): void

                      function proxyPolicy

                      proxyPolicy: (proxySettings?: ProxySettings) => RequestPolicyFactory;

                        function redirectPolicy

                        redirectPolicy: (maximumRetries?: number) => RequestPolicyFactory;

                          function serializeObject

                          serializeObject: (toSerialize: any) => any;

                            function signingPolicy

                            signingPolicy: (
                            authenticationProvider: ServiceClientCredentials
                            ) => RequestPolicyFactory;

                              function stripRequest

                              stripRequest: (request: WebResourceLike) => WebResourceLike;
                              • Returns a stripped version of the Http Request that does not contain the Authorization header.

                                Parameter request

                                The Http Request object

                                {WebResource} The stripped version of Http Request.

                              function stripResponse

                              stripResponse: (response: HttpOperationResponse) => any;
                              • Returns a stripped version of the Http Response which only contains body, headers and the status.

                                Parameter response

                                The Http Response

                                {object} The stripped version of Http Response.

                              function systemErrorRetryPolicy

                              systemErrorRetryPolicy: (
                              retryCount?: number,
                              retryInterval?: number,
                              minRetryInterval?: number,
                              maxRetryInterval?: number
                              ) => RequestPolicyFactory;

                                function throttlingRetryPolicy

                                throttlingRetryPolicy: (maxRetries?: number) => RequestPolicyFactory;

                                  function userAgentPolicy

                                  userAgentPolicy: (userAgentData?: TelemetryInfo) => RequestPolicyFactory;

                                    Classes

                                    class ApiKeyCredentials

                                    class ApiKeyCredentials implements ServiceClientCredentials {}
                                    • Authenticates to a service using an API key.

                                    constructor

                                    constructor(options: ApiKeyCredentialOptions);
                                    • Parameter options

                                      Specifies the options to be provided for auth. Either header or query needs to be provided.

                                    method signRequest

                                    signRequest: (webResource: WebResourceLike) => Promise<WebResourceLike>;
                                    • Signs a request with the values provided in the inHeader and inQuery parameter.

                                      Parameter webResource

                                      The WebResource to be signed.

                                      Returns

                                      {Promise} The signed request object.

                                    class AzureIdentityCredentialAdapter

                                    class AzureIdentityCredentialAdapter implements ServiceClientCredentials {}
                                    • This class provides a simple extension to use TokenCredential from @azure/identity library to use with legacy Azure SDKs that accept ServiceClientCredentials family of credentials for authentication.

                                    constructor

                                    constructor(azureTokenCredential: any, scopes?: string | string[]);

                                      method getToken

                                      getToken: () => Promise<TokenResponse>;

                                        method signRequest

                                        signRequest: (webResource: WebResource) => Promise<WebResource>;

                                          class BaseRequestPolicy

                                          abstract class BaseRequestPolicy implements RequestPolicy {}

                                            constructor

                                            protected constructor(
                                            _nextPolicy: RequestPolicy,
                                            _options: RequestPolicyOptionsLike
                                            );

                                              method log

                                              log: (logLevel: HttpPipelineLogLevel, message: string) => void;
                                              • Attempt to log the provided message to the provided logger. If no logger was provided or if the log level does not meat the logger's threshold, then nothing will be logged.

                                                Parameter logLevel

                                                The log level of this log.

                                                Parameter message

                                                The message of this log.

                                              method sendRequest

                                              abstract sendRequest: (
                                              webResource: WebResourceLike
                                              ) => Promise<HttpOperationResponse>;

                                                method shouldLog

                                                shouldLog: (logLevel: HttpPipelineLogLevel) => boolean;
                                                • Get whether or not a log with the provided log level should be logged.

                                                  Parameter logLevel

                                                  The log level of the log that will be logged.

                                                  Returns

                                                  Whether or not a log with the provided log level should be logged.

                                                class BasicAuthenticationCredentials

                                                class BasicAuthenticationCredentials implements ServiceClientCredentials {}

                                                  constructor

                                                  constructor(userName: string, password: string, authorizationScheme?: string);
                                                  • Creates a new BasicAuthenticationCredentials object.

                                                    Parameter userName

                                                    User name.

                                                    Parameter password

                                                    Password.

                                                    Parameter authorizationScheme

                                                    The authorization scheme.

                                                  property authorizationScheme

                                                  authorizationScheme: string;

                                                    property password

                                                    password: string;

                                                      property userName

                                                      userName: string;

                                                        method signRequest

                                                        signRequest: (webResource: WebResourceLike) => Promise<WebResourceLike>;
                                                        • Signs a request with the Authentication header.

                                                          Parameter webResource

                                                          The WebResourceLike to be signed.

                                                          Returns

                                                          {Promise} The signed request object.

                                                        class DefaultHttpClient

                                                        class NodeFetchHttpClient extends FetchHttpClient {}

                                                          method fetch

                                                          fetch: (
                                                          input: CommonRequestInfo,
                                                          init?: CommonRequestInit
                                                          ) => Promise<CommonResponse>;

                                                            method prepareRequest

                                                            prepareRequest: (httpRequest: WebResourceLike) => Promise<Partial<RequestInit>>;

                                                              method processRequest

                                                              processRequest: (operationResponse: HttpOperationResponse) => Promise<void>;

                                                                class DomainCredentials

                                                                class DomainCredentials extends ApiKeyCredentials {}

                                                                  constructor

                                                                  constructor(domainKey: string);
                                                                  • Creates a new EventGrid DomainCredentials object.

                                                                    Parameter domainKey

                                                                    The EventGrid domain key

                                                                  class HttpHeaders

                                                                  class HttpHeaders {}
                                                                  • A collection of HTTP header key/value pairs.

                                                                  constructor

                                                                  constructor(rawHeaders?: RawHttpHeaders);

                                                                    method clone

                                                                    clone: () => HttpHeaders;
                                                                    • Create a deep clone/copy of this HttpHeaders collection.

                                                                    method contains

                                                                    contains: (headerName: string) => boolean;
                                                                    • Get whether or not this header collection contains a header entry for the provided header name.

                                                                    method get

                                                                    get: (headerName: string) => string | undefined;
                                                                    • Get the header value for the provided header name, or undefined if no header exists in this collection with the provided name.

                                                                      Parameter headerName

                                                                      The name of the header.

                                                                    method headerNames

                                                                    headerNames: () => string[];
                                                                    • Get the header names that are contained in this collection.

                                                                    method headersArray

                                                                    headersArray: () => HttpHeader[];
                                                                    • Get the headers that are contained in this collection as an array.

                                                                    method headerValues

                                                                    headerValues: () => string[];
                                                                    • Get the header names that are contained in this collection.

                                                                    method rawHeaders

                                                                    rawHeaders: () => RawHttpHeaders;
                                                                    • Get the headers that are contained this collection as an object.

                                                                    method remove

                                                                    remove: (headerName: string) => boolean;
                                                                    • Remove the header with the provided headerName. Return whether or not the header existed and was removed.

                                                                      Parameter headerName

                                                                      The name of the header to remove.

                                                                    method set

                                                                    set: (headerName: string, headerValue: string | number) => void;
                                                                    • Set a header in this collection with the provided name and value. The name is case-insensitive.

                                                                      Parameter headerName

                                                                      The name of the header to set. This value is case-insensitive.

                                                                      Parameter headerValue

                                                                      The value of the header to set.

                                                                    method toJson

                                                                    toJson: () => RawHttpHeaders;
                                                                    • Get the JSON object representation of this HTTP header collection.

                                                                    method toString

                                                                    toString: () => string;
                                                                    • Get the string representation of this HTTP header collection.

                                                                    class RequestPolicyOptions

                                                                    class RequestPolicyOptions implements RequestPolicyOptionsLike {}
                                                                    • Optional properties that can be used when creating a RequestPolicy.

                                                                    constructor

                                                                    constructor(_logger?: HttpPipelineLogger);

                                                                      method log

                                                                      log: (logLevel: HttpPipelineLogLevel, message: string) => void;
                                                                      • Attempt to log the provided message to the provided logger. If no logger was provided or if the log level does not meat the logger's threshold, then nothing will be logged.

                                                                        Parameter logLevel

                                                                        The log level of this log.

                                                                        Parameter message

                                                                        The message of this log.

                                                                      method shouldLog

                                                                      shouldLog: (logLevel: HttpPipelineLogLevel) => boolean;
                                                                      • Get whether or not a log with the provided log level should be logged.

                                                                        Parameter logLevel

                                                                        The log level of the log that will be logged.

                                                                        Returns

                                                                        Whether or not a log with the provided log level should be logged.

                                                                      class RestError

                                                                      class RestError extends Error {}

                                                                        constructor

                                                                        constructor(
                                                                        message: string,
                                                                        code?: string,
                                                                        statusCode?: number,
                                                                        request?: WebResourceLike,
                                                                        response?: HttpOperationResponse,
                                                                        body?: any
                                                                        );

                                                                          property body

                                                                          body?: any;

                                                                            property code

                                                                            code?: string;

                                                                              property PARSE_ERROR

                                                                              static readonly PARSE_ERROR: string;

                                                                                property request

                                                                                request?: WebResourceLike;

                                                                                  property REQUEST_ABORTED_ERROR

                                                                                  static readonly REQUEST_ABORTED_ERROR: string;

                                                                                    property REQUEST_SEND_ERROR

                                                                                    static readonly REQUEST_SEND_ERROR: string;

                                                                                      property response

                                                                                      response?: HttpOperationResponse;

                                                                                        property statusCode

                                                                                        statusCode?: number;

                                                                                          class Serializer

                                                                                          class Serializer {}

                                                                                            constructor

                                                                                            constructor(modelMappers?: { [key: string]: any }, isXML?: boolean);

                                                                                              property isXML

                                                                                              readonly isXML?: boolean;

                                                                                                property modelMappers

                                                                                                readonly modelMappers: { [key: string]: any };

                                                                                                  method deserialize

                                                                                                  deserialize: (mapper: Mapper, responseBody: any, objectName: string) => any;
                                                                                                  • Deserialize the given object based on its metadata defined in the mapper

                                                                                                    Parameter mapper

                                                                                                    The mapper which defines the metadata of the serializable object

                                                                                                    Parameter responseBody

                                                                                                    A valid Javascript entity to be deserialized

                                                                                                    Parameter objectName

                                                                                                    Name of the deserialized object

                                                                                                    Returns

                                                                                                    {object|string|Array|number|boolean|Date|stream} A valid deserialized Javascript object

                                                                                                  method serialize

                                                                                                  serialize: (mapper: Mapper, object: any, objectName?: string) => any;
                                                                                                  • Serialize the given object based on its metadata defined in the mapper

                                                                                                    Parameter mapper

                                                                                                    The mapper which defines the metadata of the serializable object

                                                                                                    Parameter object

                                                                                                    A valid Javascript object to be serialized

                                                                                                    Parameter objectName

                                                                                                    Name of the serialized object

                                                                                                    Returns

                                                                                                    {object|string|Array|number|boolean|Date|stream} A valid serialized Javascript object

                                                                                                  method validateConstraints

                                                                                                  validateConstraints: (mapper: Mapper, value: any, objectName: string) => void;

                                                                                                    class ServiceClient

                                                                                                    class ServiceClient {}
                                                                                                    • Initializes a new instance of the ServiceClient.

                                                                                                    constructor

                                                                                                    constructor(credentials?: any, options?: ServiceClientOptions);
                                                                                                    • The ServiceClient constructor

                                                                                                      Parameter credentials

                                                                                                      The credentials object used for authentication.

                                                                                                      Parameter options

                                                                                                      The service client options that govern the behavior of the client.

                                                                                                    property baseUri

                                                                                                    protected baseUri?: string;
                                                                                                    • The base URI against which requests will be made when using this ServiceClient instance.

                                                                                                      This can be set either by setting the baseUri in the options parameter to the ServiceClient constructor or directly after constructing the ServiceClient. If set via the ServiceClient constructor when using the overload that takes the TokenCredential, and if it matches a known resource manager endpoint, this base URI sets the scope used to get the AAD token to ${baseUri}/.default instead of the default "https://management.azure.com/.default"

                                                                                                      If it is not specified, all OperationSpecs must contain a baseUrl property.

                                                                                                    property requestContentType

                                                                                                    protected requestContentType?: string;
                                                                                                    • The default request content type for the service. Used if no requestContentType is present on an OperationSpec.

                                                                                                    method sendOperationRequest

                                                                                                    sendOperationRequest: (
                                                                                                    operationArguments: OperationArguments,
                                                                                                    operationSpec: OperationSpec,
                                                                                                    callback?: ServiceCallback<any>
                                                                                                    ) => Promise<RestResponse>;
                                                                                                    • Send an HTTP request that is populated using the provided OperationSpec.

                                                                                                      Parameter operationArguments

                                                                                                      The arguments that the HTTP request's templated values will be populated from.

                                                                                                      Parameter operationSpec

                                                                                                      The OperationSpec to use to populate the httpRequest.

                                                                                                      Parameter callback

                                                                                                      The callback to call when the response is received.

                                                                                                    method sendRequest

                                                                                                    sendRequest: (
                                                                                                    options: RequestPrepareOptions | WebResourceLike
                                                                                                    ) => Promise<HttpOperationResponse>;
                                                                                                    • Send the provided httpRequest.

                                                                                                    class TokenCredentials

                                                                                                    class TokenCredentials implements ServiceClientCredentials {}
                                                                                                    • A credentials object that uses a token string and a authorzation scheme to authenticate.

                                                                                                    constructor

                                                                                                    constructor(token: string, authorizationScheme?: string);
                                                                                                    • Creates a new TokenCredentials object.

                                                                                                      Parameter token

                                                                                                      The token.

                                                                                                      Parameter authorizationScheme

                                                                                                      The authorization scheme.

                                                                                                    property authorizationScheme

                                                                                                    authorizationScheme: string;

                                                                                                      property token

                                                                                                      token: string;

                                                                                                        method signRequest

                                                                                                        signRequest: (webResource: WebResourceLike) => Promise<WebResourceLike>;
                                                                                                        • Signs a request with the Authentication header.

                                                                                                          Parameter webResource

                                                                                                          The WebResourceLike to be signed. {Promise} The signed request object.

                                                                                                        class TopicCredentials

                                                                                                        class TopicCredentials extends ApiKeyCredentials {}

                                                                                                          constructor

                                                                                                          constructor(topicKey: string);
                                                                                                          • Creates a new EventGrid TopicCredentials object.

                                                                                                            Parameter topicKey

                                                                                                            The EventGrid topic key

                                                                                                          class URLBuilder

                                                                                                          class URLBuilder {}
                                                                                                          • A class that handles creating, modifying, and parsing URLs.

                                                                                                          method appendPath

                                                                                                          appendPath: (path: string | undefined) => void;
                                                                                                          • Append the provided path to this URL's existing path. If the provided path contains a query, then it will be added to this URL as well.

                                                                                                          method getHost

                                                                                                          getHost: () => string | undefined;
                                                                                                          • Get the host that has been set in this URL.

                                                                                                          method getPath

                                                                                                          getPath: () => string | undefined;
                                                                                                          • Get the path that has been set in this URL.

                                                                                                          method getPort

                                                                                                          getPort: () => string | undefined;
                                                                                                          • Get the port that has been set in this URL.

                                                                                                          method getQuery

                                                                                                          getQuery: () => string | undefined;
                                                                                                          • Get the query in this URL.

                                                                                                          method getQueryParameterValue

                                                                                                          getQueryParameterValue: (
                                                                                                          queryParameterName: string
                                                                                                          ) => string | string[] | undefined;
                                                                                                          • Get the value of the query parameter with the provided query parameter name. If no query parameter exists with the provided name, then undefined will be returned.

                                                                                                          method getScheme

                                                                                                          getScheme: () => string | undefined;
                                                                                                          • Get the scheme that has been set in this URL.

                                                                                                          method parse

                                                                                                          static parse: (text: string) => URLBuilder;

                                                                                                            method replaceAll

                                                                                                            replaceAll: (searchValue: string, replaceValue: string) => void;
                                                                                                            • If the provided searchValue is found in this URLBuilder, then replace it with the provided replaceValue.

                                                                                                            method setHost

                                                                                                            setHost: (host: string | undefined) => void;
                                                                                                            • Set the host for this URL. If the provided host contains other parts of a URL (such as a port, path, or query), those parts will be added to this URL as well.

                                                                                                            method setPath

                                                                                                            setPath: (path: string | undefined) => void;
                                                                                                            • Set the path for this URL. If the provided path contains a query, then it will be added to this URL as well.

                                                                                                            method setPort

                                                                                                            setPort: (port: number | string | undefined) => void;
                                                                                                            • Set the port for this URL. If the provided port contains other parts of a URL (such as a path or query), those parts will be added to this URL as well.

                                                                                                            method setQuery

                                                                                                            setQuery: (query: string | undefined) => void;
                                                                                                            • Set the query in this URL.

                                                                                                            method setQueryParameter

                                                                                                            setQueryParameter: (
                                                                                                            queryParameterName: string,
                                                                                                            queryParameterValue: any
                                                                                                            ) => void;
                                                                                                            • Set a query parameter with the provided name and value in this URL's query. If the provided query parameter value is undefined or empty, then the query parameter will be removed if it existed.

                                                                                                            method setScheme

                                                                                                            setScheme: (scheme: string | undefined) => void;
                                                                                                            • Set the scheme/protocol for this URL. If the provided scheme contains other parts of a URL (such as a host, port, path, or query), those parts will be added to this URL as well.

                                                                                                            method toString

                                                                                                            toString: () => string;

                                                                                                              class URLQuery

                                                                                                              class URLQuery {}
                                                                                                              • A class that handles the query portion of a URLBuilder.

                                                                                                              method any

                                                                                                              any: () => boolean;
                                                                                                              • Get whether or not there any query parameters in this URLQuery.

                                                                                                              method get

                                                                                                              get: (parameterName: string) => string | string[] | undefined;
                                                                                                              • Get the value of the query parameter with the provided name. If no parameter exists with the provided parameter name, then undefined will be returned.

                                                                                                              method parse

                                                                                                              static parse: (text: string) => URLQuery;
                                                                                                              • Parse a URLQuery from the provided text.

                                                                                                              method set

                                                                                                              set: (parameterName: string, parameterValue: any) => void;
                                                                                                              • Set a query parameter with the provided name and value. If the parameterValue is undefined or empty, then this will attempt to remove an existing query parameter with the provided parameterName.

                                                                                                              method toString

                                                                                                              toString: () => string;
                                                                                                              • Get the string representation of this query. The return value will not start with a "?".

                                                                                                              class WebResource

                                                                                                              class WebResource {}
                                                                                                              • Creates a new WebResource object.

                                                                                                                This class provides an abstraction over a REST call by being library / implementation agnostic and wrapping the necessary properties to initiate a request.

                                                                                                              constructor

                                                                                                              constructor(
                                                                                                              url?: string,
                                                                                                              method?: HttpMethods,
                                                                                                              body?: any,
                                                                                                              query?: { [key: string]: any },
                                                                                                              headers?: { [key: string]: any } | HttpHeadersLike,
                                                                                                              streamResponseBody?: boolean,
                                                                                                              withCredentials?: boolean,
                                                                                                              abortSignal?: AbortSignalLike,
                                                                                                              timeout?: number,
                                                                                                              onUploadProgress?: (progress: TransferProgressEvent) => void,
                                                                                                              onDownloadProgress?: (progress: TransferProgressEvent) => void,
                                                                                                              proxySettings?: ProxySettings,
                                                                                                              keepAlive?: boolean,
                                                                                                              agentSettings?: AgentSettings,
                                                                                                              redirectLimit?: number
                                                                                                              );

                                                                                                                property abortSignal

                                                                                                                abortSignal?: AbortSignalLike;

                                                                                                                  property agentSettings

                                                                                                                  agentSettings?: AgentSettings;

                                                                                                                    property body

                                                                                                                    body?: any;

                                                                                                                      property formData

                                                                                                                      formData?: any;

                                                                                                                        property headers

                                                                                                                        headers: HttpHeadersLike;

                                                                                                                          property keepAlive

                                                                                                                          keepAlive?: boolean;

                                                                                                                            property method

                                                                                                                            method: HttpMethods;

                                                                                                                              property onDownloadProgress

                                                                                                                              onDownloadProgress?: (progress: TransferProgressEvent) => void;
                                                                                                                              • Callback which fires upon download progress.

                                                                                                                              property onUploadProgress

                                                                                                                              onUploadProgress?: (progress: TransferProgressEvent) => void;
                                                                                                                              • Callback which fires upon upload progress.

                                                                                                                              property operationResponseGetter

                                                                                                                              operationResponseGetter?: (
                                                                                                                              operationSpec: OperationSpec,
                                                                                                                              response: HttpOperationResponse
                                                                                                                              ) => undefined | OperationResponse;
                                                                                                                              • A function that returns the proper OperationResponse for the given OperationSpec and HttpOperationResponse combination. If this is undefined, then a simple status code lookup will be used.

                                                                                                                              property operationSpec

                                                                                                                              operationSpec?: OperationSpec;

                                                                                                                                property proxySettings

                                                                                                                                proxySettings?: ProxySettings;

                                                                                                                                  property query

                                                                                                                                  query?: { [key: string]: any };

                                                                                                                                    property redirectLimit

                                                                                                                                    redirectLimit?: number;

                                                                                                                                      property shouldDeserialize

                                                                                                                                      shouldDeserialize?: boolean | ((response: HttpOperationResponse) => boolean);
                                                                                                                                      • Whether or not the HttpOperationResponse should be deserialized. If this is undefined, then the HttpOperationResponse should be deserialized.

                                                                                                                                      property streamResponseBody

                                                                                                                                      streamResponseBody?: boolean;
                                                                                                                                      • Whether or not the body of the HttpOperationResponse should be treated as a stream.

                                                                                                                                      property timeout

                                                                                                                                      timeout: number;

                                                                                                                                        property url

                                                                                                                                        url: string;

                                                                                                                                          property withCredentials

                                                                                                                                          withCredentials: boolean;

                                                                                                                                            method clone

                                                                                                                                            clone: () => WebResource;
                                                                                                                                            • Clone this WebResource HTTP request object.

                                                                                                                                              Returns

                                                                                                                                              {WebResource} The clone of this WebResource HTTP request object.

                                                                                                                                            method prepare

                                                                                                                                            prepare: (options: RequestPrepareOptions) => WebResource;
                                                                                                                                            • Prepares the request.

                                                                                                                                              Parameter options

                                                                                                                                              Options to provide for preparing the request.

                                                                                                                                              Returns

                                                                                                                                              {WebResource} Returns the prepared WebResource (HTTP Request) object that needs to be given to the request pipeline.

                                                                                                                                            method validateRequestProperties

                                                                                                                                            validateRequestProperties: () => void;
                                                                                                                                            • Validates that the required properties such as method, url, headers["Content-Type"], headers["accept-language"] are defined. It will throw an error if one of the above mentioned properties are not defined.

                                                                                                                                            Interfaces

                                                                                                                                            interface AbortSignalLike

                                                                                                                                            interface AbortSignalLike {}
                                                                                                                                            • Allows the request to be aborted upon firing of the "abort" event. Compatible with the browser built-in AbortSignal and common polyfills.

                                                                                                                                            property aborted

                                                                                                                                            readonly aborted: boolean;

                                                                                                                                              property addEventListener

                                                                                                                                              addEventListener: (
                                                                                                                                              type: 'abort',
                                                                                                                                              listener: (this: AbortSignalLike, ev: Event) => any,
                                                                                                                                              options?: any
                                                                                                                                              ) => void;

                                                                                                                                                property dispatchEvent

                                                                                                                                                dispatchEvent: (event: Event) => boolean;

                                                                                                                                                  property onabort

                                                                                                                                                  onabort: ((this: AbortSignalLike, ev: Event) => any) | null;

                                                                                                                                                    property removeEventListener

                                                                                                                                                    removeEventListener: (
                                                                                                                                                    type: 'abort',
                                                                                                                                                    listener: (this: AbortSignalLike, ev: Event) => any,
                                                                                                                                                    options?: any
                                                                                                                                                    ) => void;

                                                                                                                                                      interface ApiKeyCredentialOptions

                                                                                                                                                      interface ApiKeyCredentialOptions {}
                                                                                                                                                      • ApiKeyCredentialOptions Describes the options to be provided while creating an instance of ApiKeyCredentials

                                                                                                                                                      property inHeader

                                                                                                                                                      inHeader?: {
                                                                                                                                                      [x: string]: any;
                                                                                                                                                      };
                                                                                                                                                      • A key value pair of the header parameters that need to be applied to the request.

                                                                                                                                                      property inQuery

                                                                                                                                                      inQuery?: {
                                                                                                                                                      [x: string]: any;
                                                                                                                                                      };
                                                                                                                                                      • A key value pair of the query parameters that need to be applied to the request.

                                                                                                                                                      interface BaseMapper

                                                                                                                                                      interface BaseMapper {}

                                                                                                                                                        property constraints

                                                                                                                                                        constraints?: MapperConstraints;

                                                                                                                                                          property defaultValue

                                                                                                                                                          defaultValue?: any;

                                                                                                                                                            property isConstant

                                                                                                                                                            isConstant?: boolean;

                                                                                                                                                              property nullable

                                                                                                                                                              nullable?: boolean;

                                                                                                                                                                property readOnly

                                                                                                                                                                readOnly?: boolean;

                                                                                                                                                                  property required

                                                                                                                                                                  required?: boolean;

                                                                                                                                                                    property serializedName

                                                                                                                                                                    serializedName?: string;

                                                                                                                                                                      property type

                                                                                                                                                                      type: MapperType;

                                                                                                                                                                        property xmlElementName

                                                                                                                                                                        xmlElementName?: string;

                                                                                                                                                                          property xmlIsAttribute

                                                                                                                                                                          xmlIsAttribute?: boolean;

                                                                                                                                                                            property xmlIsWrapped

                                                                                                                                                                            xmlIsWrapped?: boolean;

                                                                                                                                                                              property xmlName

                                                                                                                                                                              xmlName?: string;

                                                                                                                                                                                interface CompositeMapper

                                                                                                                                                                                interface CompositeMapper extends BaseMapper {}

                                                                                                                                                                                  property type

                                                                                                                                                                                  type: CompositeMapperType;

                                                                                                                                                                                    interface CompositeMapperType

                                                                                                                                                                                    interface CompositeMapperType {}

                                                                                                                                                                                      property additionalProperties

                                                                                                                                                                                      additionalProperties?: Mapper;

                                                                                                                                                                                        property className

                                                                                                                                                                                        className?: string;

                                                                                                                                                                                          property modelProperties

                                                                                                                                                                                          modelProperties?: {
                                                                                                                                                                                          [propertyName: string]: Mapper;
                                                                                                                                                                                          };

                                                                                                                                                                                            property name

                                                                                                                                                                                            name: 'Composite';

                                                                                                                                                                                              property polymorphicDiscriminator

                                                                                                                                                                                              polymorphicDiscriminator?: PolymorphicDiscriminator;

                                                                                                                                                                                                property uberParent

                                                                                                                                                                                                uberParent?: string;

                                                                                                                                                                                                  interface DictionaryMapper

                                                                                                                                                                                                  interface DictionaryMapper extends BaseMapper {}

                                                                                                                                                                                                    property headerCollectionPrefix

                                                                                                                                                                                                    headerCollectionPrefix?: string;

                                                                                                                                                                                                      property type

                                                                                                                                                                                                      type: DictionaryMapperType;

                                                                                                                                                                                                        interface DictionaryMapperType

                                                                                                                                                                                                        interface DictionaryMapperType {}

                                                                                                                                                                                                          property name

                                                                                                                                                                                                          name: 'Dictionary';

                                                                                                                                                                                                            property value

                                                                                                                                                                                                            value: Mapper;

                                                                                                                                                                                                              interface EnumMapper

                                                                                                                                                                                                              interface EnumMapper extends BaseMapper {}

                                                                                                                                                                                                                property type

                                                                                                                                                                                                                type: EnumMapperType;

                                                                                                                                                                                                                  interface EnumMapperType

                                                                                                                                                                                                                  interface EnumMapperType {}

                                                                                                                                                                                                                    property allowedValues

                                                                                                                                                                                                                    allowedValues: any[];

                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                      name: 'Enum';

                                                                                                                                                                                                                        interface HttpClient

                                                                                                                                                                                                                        interface HttpClient extends RequestPolicy {}
                                                                                                                                                                                                                        • An interface that can send HttpRequests and receive promised HttpResponses.

                                                                                                                                                                                                                        interface HttpHeadersLike

                                                                                                                                                                                                                        interface HttpHeadersLike {}
                                                                                                                                                                                                                        • A collection of HTTP header key/value pairs.

                                                                                                                                                                                                                        method clone

                                                                                                                                                                                                                        clone: () => HttpHeadersLike;
                                                                                                                                                                                                                        • Create a deep clone/copy of this HttpHeaders collection.

                                                                                                                                                                                                                        method contains

                                                                                                                                                                                                                        contains: (headerName: string) => boolean;
                                                                                                                                                                                                                        • Get whether or not this header collection contains a header entry for the provided header name.

                                                                                                                                                                                                                        method get

                                                                                                                                                                                                                        get: (headerName: string) => string | undefined;
                                                                                                                                                                                                                        • Get the header value for the provided header name, or undefined if no header exists in this collection with the provided name.

                                                                                                                                                                                                                          Parameter headerName

                                                                                                                                                                                                                          The name of the header.

                                                                                                                                                                                                                        method headerNames

                                                                                                                                                                                                                        headerNames: () => string[];
                                                                                                                                                                                                                        • Get the header names that are contained in this collection.

                                                                                                                                                                                                                        method headersArray

                                                                                                                                                                                                                        headersArray: () => HttpHeader[];
                                                                                                                                                                                                                        • Get the headers that are contained in this collection as an array.

                                                                                                                                                                                                                        method headerValues

                                                                                                                                                                                                                        headerValues: () => string[];
                                                                                                                                                                                                                        • Get the header values that are contained in this collection.

                                                                                                                                                                                                                        method rawHeaders

                                                                                                                                                                                                                        rawHeaders: () => RawHttpHeaders;
                                                                                                                                                                                                                        • Get the headers that are contained this collection as an object.

                                                                                                                                                                                                                        method remove

                                                                                                                                                                                                                        remove: (headerName: string) => boolean;
                                                                                                                                                                                                                        • Remove the header with the provided headerName. Return whether or not the header existed and was removed.

                                                                                                                                                                                                                          Parameter headerName

                                                                                                                                                                                                                          The name of the header to remove.

                                                                                                                                                                                                                        method set

                                                                                                                                                                                                                        set: (headerName: string, headerValue: string | number) => void;
                                                                                                                                                                                                                        • Set a header in this collection with the provided name and value. The name is case-insensitive.

                                                                                                                                                                                                                          Parameter headerName

                                                                                                                                                                                                                          The name of the header to set. This value is case-insensitive.

                                                                                                                                                                                                                          Parameter headerValue

                                                                                                                                                                                                                          The value of the header to set.

                                                                                                                                                                                                                        method toJson

                                                                                                                                                                                                                        toJson: () => RawHttpHeaders;
                                                                                                                                                                                                                        • Get the JSON object representation of this HTTP header collection. The result is the same as rawHeaders().

                                                                                                                                                                                                                        interface HttpOperationResponse

                                                                                                                                                                                                                        interface HttpOperationResponse extends HttpResponse {}
                                                                                                                                                                                                                        • Wrapper object for http request and response. Deserialized object is stored in the parsedBody property when the response body is received in JSON or XML.

                                                                                                                                                                                                                        property blobBody

                                                                                                                                                                                                                        blobBody?: Promise<Blob>;
                                                                                                                                                                                                                        • BROWSER ONLY

                                                                                                                                                                                                                          The response body as a browser Blob. Always undefined in node.js.

                                                                                                                                                                                                                        property bodyAsText

                                                                                                                                                                                                                        bodyAsText?: string | null;
                                                                                                                                                                                                                        • The response body as text (string format)

                                                                                                                                                                                                                        property parsedBody

                                                                                                                                                                                                                        parsedBody?: any;
                                                                                                                                                                                                                        • The response body as parsed JSON or XML

                                                                                                                                                                                                                        property parsedHeaders

                                                                                                                                                                                                                        parsedHeaders?: {
                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                        };
                                                                                                                                                                                                                        • The parsed HTTP response headers.

                                                                                                                                                                                                                        property readableStreamBody

                                                                                                                                                                                                                        readableStreamBody?: NodeJS.ReadableStream;
                                                                                                                                                                                                                        • NODEJS ONLY

                                                                                                                                                                                                                          The response body as a node.js Readable stream. Always undefined in the browser.

                                                                                                                                                                                                                        property redirected

                                                                                                                                                                                                                        redirected?: boolean;
                                                                                                                                                                                                                        • The redirected property indicates whether the response is the result of a request which was redirected.

                                                                                                                                                                                                                        property url

                                                                                                                                                                                                                        url?: string;
                                                                                                                                                                                                                        • The url property contains the URL of the response. The value will be the final URL obtained after any redirects.

                                                                                                                                                                                                                        interface HttpPipelineLogger

                                                                                                                                                                                                                        interface HttpPipelineLogger {}
                                                                                                                                                                                                                        • A Logger that can be added to a HttpPipeline. This enables each RequestPolicy to log messages that can be used for debugging purposes.

                                                                                                                                                                                                                        property minimumLogLevel

                                                                                                                                                                                                                        minimumLogLevel: HttpPipelineLogLevel;
                                                                                                                                                                                                                        • The log level threshold for what logs will be logged.

                                                                                                                                                                                                                        method log

                                                                                                                                                                                                                        log: (logLevel: HttpPipelineLogLevel, message: string) => void;
                                                                                                                                                                                                                        • Log the provided message.

                                                                                                                                                                                                                          Parameter logLevel

                                                                                                                                                                                                                          The HttpLogDetailLevel associated with this message.

                                                                                                                                                                                                                          Parameter message

                                                                                                                                                                                                                          The message to log.

                                                                                                                                                                                                                        interface HttpResponse

                                                                                                                                                                                                                        interface HttpResponse {}
                                                                                                                                                                                                                        • The properties on an HTTP response which will always be present.

                                                                                                                                                                                                                        property headers

                                                                                                                                                                                                                        headers: HttpHeadersLike;
                                                                                                                                                                                                                        • The HTTP response headers.

                                                                                                                                                                                                                        property request

                                                                                                                                                                                                                        request: WebResourceLike;
                                                                                                                                                                                                                        • The raw request

                                                                                                                                                                                                                        property status

                                                                                                                                                                                                                        status: number;
                                                                                                                                                                                                                        • The HTTP response status (e.g. 200)

                                                                                                                                                                                                                        interface MapperConstraints

                                                                                                                                                                                                                        interface MapperConstraints {}

                                                                                                                                                                                                                          property ExclusiveMaximum

                                                                                                                                                                                                                          ExclusiveMaximum?: number;

                                                                                                                                                                                                                            property ExclusiveMinimum

                                                                                                                                                                                                                            ExclusiveMinimum?: number;

                                                                                                                                                                                                                              property InclusiveMaximum

                                                                                                                                                                                                                              InclusiveMaximum?: number;

                                                                                                                                                                                                                                property InclusiveMinimum

                                                                                                                                                                                                                                InclusiveMinimum?: number;

                                                                                                                                                                                                                                  property MaxItems

                                                                                                                                                                                                                                  MaxItems?: number;

                                                                                                                                                                                                                                    property MaxLength

                                                                                                                                                                                                                                    MaxLength?: number;

                                                                                                                                                                                                                                      property MinItems

                                                                                                                                                                                                                                      MinItems?: number;

                                                                                                                                                                                                                                        property MinLength

                                                                                                                                                                                                                                        MinLength?: number;

                                                                                                                                                                                                                                          property MultipleOf

                                                                                                                                                                                                                                          MultipleOf?: number;

                                                                                                                                                                                                                                            property Pattern

                                                                                                                                                                                                                                            Pattern?: RegExp;

                                                                                                                                                                                                                                              property UniqueItems

                                                                                                                                                                                                                                              UniqueItems?: true;

                                                                                                                                                                                                                                                interface OperationArguments

                                                                                                                                                                                                                                                interface OperationArguments {}
                                                                                                                                                                                                                                                • A collection of properties that apply to a single invocation of an operation.

                                                                                                                                                                                                                                                property options

                                                                                                                                                                                                                                                options?: RequestOptionsBase;
                                                                                                                                                                                                                                                • The optional arugments that are provided to an operation.

                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                [parameterName: string]: any;
                                                                                                                                                                                                                                                • The parameters that were passed to the operation method.

                                                                                                                                                                                                                                                interface OperationParameter

                                                                                                                                                                                                                                                interface OperationParameter {}
                                                                                                                                                                                                                                                • A common interface that all Operation parameter's extend.

                                                                                                                                                                                                                                                property mapper

                                                                                                                                                                                                                                                mapper: Mapper;
                                                                                                                                                                                                                                                • The mapper that defines how to validate and serialize this parameter's value.

                                                                                                                                                                                                                                                property parameterPath

                                                                                                                                                                                                                                                parameterPath: ParameterPath;
                                                                                                                                                                                                                                                • The path to this parameter's value in OperationArguments or the object that contains paths for each property's value in OperationArguments.

                                                                                                                                                                                                                                                interface OperationQueryParameter

                                                                                                                                                                                                                                                interface OperationQueryParameter extends OperationParameter {}
                                                                                                                                                                                                                                                • A parameter for an operation that will be added as a query parameter to the operation's HTTP request.

                                                                                                                                                                                                                                                property collectionFormat

                                                                                                                                                                                                                                                collectionFormat?: QueryCollectionFormat;
                                                                                                                                                                                                                                                • If this query parameter's value is a collection, what type of format should the value be converted to.

                                                                                                                                                                                                                                                property skipEncoding

                                                                                                                                                                                                                                                skipEncoding?: boolean;
                                                                                                                                                                                                                                                • Whether or not to skip encoding the query parameter's value before adding it to the URL.

                                                                                                                                                                                                                                                interface OperationResponse

                                                                                                                                                                                                                                                interface OperationResponse {}
                                                                                                                                                                                                                                                • An OperationResponse that can be returned from an operation request for a single status code.

                                                                                                                                                                                                                                                property bodyMapper

                                                                                                                                                                                                                                                bodyMapper?: Mapper;
                                                                                                                                                                                                                                                • The mapper that will be used to deserialize the response body.

                                                                                                                                                                                                                                                property headersMapper

                                                                                                                                                                                                                                                headersMapper?: Mapper;
                                                                                                                                                                                                                                                • The mapper that will be used to deserialize the response headers.

                                                                                                                                                                                                                                                interface OperationSpec

                                                                                                                                                                                                                                                interface OperationSpec {}
                                                                                                                                                                                                                                                • A specification that defines an operation.

                                                                                                                                                                                                                                                property baseUrl

                                                                                                                                                                                                                                                readonly baseUrl?: string;
                                                                                                                                                                                                                                                • The URL that was provided in the service's specification. This will still have all of the URL template variables in it. If this is not provided when the OperationSpec is created, then it will be populated by a "baseUri" property on the ServiceClient.

                                                                                                                                                                                                                                                property contentType

                                                                                                                                                                                                                                                readonly contentType?: string;
                                                                                                                                                                                                                                                • The content type of the request body. This value will be used as the "Content-Type" header if it is provided.

                                                                                                                                                                                                                                                property formDataParameters

                                                                                                                                                                                                                                                readonly formDataParameters?: ReadonlyArray<OperationParameter>;
                                                                                                                                                                                                                                                • The parameters to the operation method that will be used to create a formdata body for the operation's HTTP request.

                                                                                                                                                                                                                                                property headerParameters

                                                                                                                                                                                                                                                readonly headerParameters?: ReadonlyArray<OperationParameter>;
                                                                                                                                                                                                                                                • The parameters to the operation method that will be converted to headers on the operation's HTTP request.

                                                                                                                                                                                                                                                property httpMethod

                                                                                                                                                                                                                                                readonly httpMethod: HttpMethods;
                                                                                                                                                                                                                                                • The HTTP method that should be used by requests for this operation.

                                                                                                                                                                                                                                                property isXML

                                                                                                                                                                                                                                                readonly isXML?: boolean;
                                                                                                                                                                                                                                                • Whether or not this operation uses XML request and response bodies.

                                                                                                                                                                                                                                                property path

                                                                                                                                                                                                                                                readonly path?: string;
                                                                                                                                                                                                                                                • The fixed path for this operation's URL. This will still have all of the URL template variables in it.

                                                                                                                                                                                                                                                property queryParameters

                                                                                                                                                                                                                                                readonly queryParameters?: ReadonlyArray<OperationQueryParameter>;
                                                                                                                                                                                                                                                • The parameters to the operation method that will be added to the constructed URL's query.

                                                                                                                                                                                                                                                property requestBody

                                                                                                                                                                                                                                                readonly requestBody?: OperationParameter;
                                                                                                                                                                                                                                                • The parameter that will be used to construct the HTTP request's body.

                                                                                                                                                                                                                                                property responses

                                                                                                                                                                                                                                                readonly responses: {
                                                                                                                                                                                                                                                [responseCode: string]: OperationResponse;
                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                • The different types of responses that this operation can return based on what status code is returned.

                                                                                                                                                                                                                                                property serializer

                                                                                                                                                                                                                                                readonly serializer: Serializer;
                                                                                                                                                                                                                                                • The serializer to use in this operation.

                                                                                                                                                                                                                                                property urlParameters

                                                                                                                                                                                                                                                readonly urlParameters?: ReadonlyArray<OperationURLParameter>;
                                                                                                                                                                                                                                                • The parameters to the operation method that will be substituted into the constructed URL.

                                                                                                                                                                                                                                                interface OperationURLParameter

                                                                                                                                                                                                                                                interface OperationURLParameter extends OperationParameter {}
                                                                                                                                                                                                                                                • A parameter for an operation that will be substituted into the operation's request URL.

                                                                                                                                                                                                                                                property skipEncoding

                                                                                                                                                                                                                                                skipEncoding?: boolean;
                                                                                                                                                                                                                                                • Whether or not to skip encoding the URL parameter's value before adding it to the URL.

                                                                                                                                                                                                                                                interface ParameterValue

                                                                                                                                                                                                                                                interface ParameterValue {}
                                                                                                                                                                                                                                                • The Parameter value provided for path or query parameters in RequestPrepareOptions

                                                                                                                                                                                                                                                property skipUrlEncoding

                                                                                                                                                                                                                                                skipUrlEncoding: boolean;

                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                  value: any;

                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                      interface PolymorphicDiscriminator

                                                                                                                                                                                                                                                      interface PolymorphicDiscriminator {}

                                                                                                                                                                                                                                                        property clientName

                                                                                                                                                                                                                                                        clientName: string;

                                                                                                                                                                                                                                                          property serializedName

                                                                                                                                                                                                                                                          serializedName: string;

                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                            [key: string]: string;

                                                                                                                                                                                                                                                              interface RequestOptionsBase

                                                                                                                                                                                                                                                              interface RequestOptionsBase {}
                                                                                                                                                                                                                                                              • Describes the base structure of the options object that will be used in every operation.

                                                                                                                                                                                                                                                              property abortSignal

                                                                                                                                                                                                                                                              abortSignal?: AbortSignalLike;
                                                                                                                                                                                                                                                              • The signal which can be used to abort requests.

                                                                                                                                                                                                                                                              property customHeaders

                                                                                                                                                                                                                                                              customHeaders?: {
                                                                                                                                                                                                                                                              [key: string]: string;
                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                              • {object} [customHeaders] User defined custom request headers that will be applied before the request is sent.

                                                                                                                                                                                                                                                              property onDownloadProgress

                                                                                                                                                                                                                                                              onDownloadProgress?: (progress: TransferProgressEvent) => void;
                                                                                                                                                                                                                                                              • Callback which fires upon download progress.

                                                                                                                                                                                                                                                              property onUploadProgress

                                                                                                                                                                                                                                                              onUploadProgress?: (progress: TransferProgressEvent) => void;
                                                                                                                                                                                                                                                              • Callback which fires upon upload progress.

                                                                                                                                                                                                                                                              property timeout

                                                                                                                                                                                                                                                              timeout?: number;
                                                                                                                                                                                                                                                              • The number of milliseconds a request can take before automatically being terminated.

                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                              [key: string]: any;

                                                                                                                                                                                                                                                                interface RequestPolicy

                                                                                                                                                                                                                                                                interface RequestPolicy {}

                                                                                                                                                                                                                                                                  method sendRequest

                                                                                                                                                                                                                                                                  sendRequest: (httpRequest: WebResourceLike) => Promise<HttpOperationResponse>;

                                                                                                                                                                                                                                                                    interface RequestPolicyOptionsLike

                                                                                                                                                                                                                                                                    interface RequestPolicyOptionsLike {}
                                                                                                                                                                                                                                                                    • Optional properties that can be used when creating a RequestPolicy.

                                                                                                                                                                                                                                                                    method log

                                                                                                                                                                                                                                                                    log: (logLevel: HttpPipelineLogLevel, message: string) => void;
                                                                                                                                                                                                                                                                    • Attempt to log the provided message to the provided logger. If no logger was provided or if the log level does not meet the logger's threshold, then nothing will be logged.

                                                                                                                                                                                                                                                                      Parameter logLevel

                                                                                                                                                                                                                                                                      The log level of this log.

                                                                                                                                                                                                                                                                      Parameter message

                                                                                                                                                                                                                                                                      The message of this log.

                                                                                                                                                                                                                                                                    method shouldLog

                                                                                                                                                                                                                                                                    shouldLog: (logLevel: HttpPipelineLogLevel) => boolean;
                                                                                                                                                                                                                                                                    • Get whether or not a log with the provided log level should be logged.

                                                                                                                                                                                                                                                                      Parameter logLevel

                                                                                                                                                                                                                                                                      The log level of the log that will be logged.

                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                      Whether or not a log with the provided log level should be logged.

                                                                                                                                                                                                                                                                    interface RequestPrepareOptions

                                                                                                                                                                                                                                                                    interface RequestPrepareOptions {}

                                                                                                                                                                                                                                                                      property abortSignal

                                                                                                                                                                                                                                                                      abortSignal?: AbortSignalLike;

                                                                                                                                                                                                                                                                        property baseUrl

                                                                                                                                                                                                                                                                        baseUrl?: string;
                                                                                                                                                                                                                                                                        • The base url of the request. Default value is: "https://management.azure.com". This is applicable only with pathTemplate. If you are providing options.url then it is expected that you provide the complete url.

                                                                                                                                                                                                                                                                        property body

                                                                                                                                                                                                                                                                        body?: any;
                                                                                                                                                                                                                                                                        • The request body. It can be of any type. This value will be serialized if it is not a stream.

                                                                                                                                                                                                                                                                        property bodyIsStream

                                                                                                                                                                                                                                                                        bodyIsStream?: boolean;
                                                                                                                                                                                                                                                                        • Indicates whether the request body is a stream (useful for file upload scenarios).

                                                                                                                                                                                                                                                                        property deserializationMapper

                                                                                                                                                                                                                                                                        deserializationMapper?: object;
                                                                                                                                                                                                                                                                        • Provides information on how to deserialize the response body.

                                                                                                                                                                                                                                                                        property disableClientRequestId

                                                                                                                                                                                                                                                                        disableClientRequestId?: boolean;
                                                                                                                                                                                                                                                                        • When set to true, instructs the client to not set "x-ms-client-request-id" header to a new Guid().

                                                                                                                                                                                                                                                                        property disableJsonStringifyOnBody

                                                                                                                                                                                                                                                                        disableJsonStringifyOnBody?: boolean;
                                                                                                                                                                                                                                                                        • Indicates whether this method should JSON.stringify() the request body. Default value: false.

                                                                                                                                                                                                                                                                        property formData

                                                                                                                                                                                                                                                                        formData?: {
                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          property headers

                                                                                                                                                                                                                                                                          headers?: {
                                                                                                                                                                                                                                                                          [key: string]: any;
                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                          • A dictionary of request headers that need to be applied to the request. Here the key is the "header-name" and the value is the "header-value". The header-value MUST be of type string. - ContentType must be provided with the key name as "Content-Type". Default value "application/json; charset=utf-8". - "Transfer-Encoding" is set to "chunked" by default if "options.bodyIsStream" is set to true. - "Content-Type" is set to "application/octet-stream" by default if "options.bodyIsStream" is set to true. - "accept-language" by default is set to "en-US" - "x-ms-client-request-id" by default is set to a new Guid. To not generate a guid for the request, please set options.disableClientRequestId to true

                                                                                                                                                                                                                                                                          property mappers

                                                                                                                                                                                                                                                                          mappers?: {
                                                                                                                                                                                                                                                                          [x: string]: any;
                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                          • A dictionary of mappers that may be used while [de]serialization.

                                                                                                                                                                                                                                                                          property method

                                                                                                                                                                                                                                                                          method: HttpMethods;
                                                                                                                                                                                                                                                                          • The HTTP request method. Valid values are "GET", "PUT", "HEAD", "DELETE", "OPTIONS", "POST", or "PATCH".

                                                                                                                                                                                                                                                                          property onDownloadProgress

                                                                                                                                                                                                                                                                          onDownloadProgress?: (progress: TransferProgressEvent) => void;

                                                                                                                                                                                                                                                                            property onUploadProgress

                                                                                                                                                                                                                                                                            onUploadProgress?: (progress: TransferProgressEvent) => void;

                                                                                                                                                                                                                                                                              property pathParameters

                                                                                                                                                                                                                                                                              pathParameters?: {
                                                                                                                                                                                                                                                                              [key: string]: any | ParameterValue;
                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                              • A dictionary of path parameters that need to be replaced with actual values in the pathTemplate. Here the key is the "path-parameter-name" and the value is the "path-parameter-value". The "path-parameter-value" can be of type "string" or it can be of type "object". The "object" format should be used when you want to skip url encoding. While using the object format, the object must have a property named value which provides the "path-parameter-value". Example: - path-parameter-value in "object" format: { "path-parameter-name": { value: "path-parameter-value", skipUrlEncoding: true } } - path-parameter-value in "string" format: { "path-parameter-name": "path-parameter-value" }.

                                                                                                                                                                                                                                                                              property pathTemplate

                                                                                                                                                                                                                                                                              pathTemplate?: string;
                                                                                                                                                                                                                                                                              • The path template of the request url. Either provide the "url" or provide the "pathTemplate" in the options object. Both the options are mutually exclusive. Example: "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}"

                                                                                                                                                                                                                                                                              property queryParameters

                                                                                                                                                                                                                                                                              queryParameters?: {
                                                                                                                                                                                                                                                                              [key: string]: any | ParameterValue;
                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                              • A dictionary of query parameters to be appended to the url, where the "key" is the "query-parameter-name" and the "value" is the "query-parameter-value". The "query-parameter-value" can be of type "string" or it can be of type "object". The "object" format should be used when you want to skip url encoding. While using the object format, the object must have a property named value which provides the "query-parameter-value". Example: - query-parameter-value in "object" format: { "query-parameter-name": { value: "query-parameter-value", skipUrlEncoding: true } } - query-parameter-value in "string" format: { "query-parameter-name": "query-parameter-value"}. Note: "If options.url already has some query parameters, then the value provided in options.queryParameters will be appended to the url.

                                                                                                                                                                                                                                                                              property redirectLimit

                                                                                                                                                                                                                                                                              redirectLimit?: number;
                                                                                                                                                                                                                                                                              • Limit the number of redirects followed for this request. If set to 0, redirects will not be followed. If left undefined the default redirect behaviour of the underlying node_fetch will apply.

                                                                                                                                                                                                                                                                              property serializationMapper

                                                                                                                                                                                                                                                                              serializationMapper?: Mapper;
                                                                                                                                                                                                                                                                              • Provides information on how to serialize the request body.

                                                                                                                                                                                                                                                                              property streamResponseBody

                                                                                                                                                                                                                                                                              streamResponseBody?: boolean;

                                                                                                                                                                                                                                                                                property url

                                                                                                                                                                                                                                                                                url?: string;
                                                                                                                                                                                                                                                                                • The request url. It may or may not have query parameters in it. Either provide the "url" or provide the "pathTemplate" in the options object. Both the options are mutually exclusive.

                                                                                                                                                                                                                                                                                interface RestResponse

                                                                                                                                                                                                                                                                                interface RestResponse {}
                                                                                                                                                                                                                                                                                • The flattened response to a REST call. Contains the underlying HttpOperationResponse as well as the merged properties of the parsedBody, parsedHeaders, etc.

                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                [key: string]: any;

                                                                                                                                                                                                                                                                                  interface SequenceMapper

                                                                                                                                                                                                                                                                                  interface SequenceMapper extends BaseMapper {}

                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                    type: SequenceMapperType;

                                                                                                                                                                                                                                                                                      interface SequenceMapperType

                                                                                                                                                                                                                                                                                      interface SequenceMapperType {}

                                                                                                                                                                                                                                                                                        property element

                                                                                                                                                                                                                                                                                        element: Mapper;

                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                          name: 'Sequence';

                                                                                                                                                                                                                                                                                            interface ServiceCallback

                                                                                                                                                                                                                                                                                            interface ServiceCallback<TResult> {}
                                                                                                                                                                                                                                                                                            • Service callback that is returned for REST requests initiated by the service client.

                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                            err: Error | RestError | null,
                                                                                                                                                                                                                                                                                            result?: TResult,
                                                                                                                                                                                                                                                                                            request?: WebResourceLike,
                                                                                                                                                                                                                                                                                            response?: HttpOperationResponse
                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                            • A method that will be invoked as a callback to a service function.

                                                                                                                                                                                                                                                                                              Parameter err

                                                                                                                                                                                                                                                                                              The error occurred if any, while executing the request; otherwise null.

                                                                                                                                                                                                                                                                                              Parameter result

                                                                                                                                                                                                                                                                                              The deserialized response body if an error did not occur.

                                                                                                                                                                                                                                                                                              Parameter request

                                                                                                                                                                                                                                                                                              The raw/actual request sent to the server if an error did not occur.

                                                                                                                                                                                                                                                                                              Parameter response

                                                                                                                                                                                                                                                                                              The raw/actual response from the server if an error did not occur.

                                                                                                                                                                                                                                                                                            interface ServiceClientCredentials

                                                                                                                                                                                                                                                                                            interface ServiceClientCredentials {}

                                                                                                                                                                                                                                                                                              method signRequest

                                                                                                                                                                                                                                                                                              signRequest: (webResource: WebResourceLike) => Promise<WebResourceLike>;
                                                                                                                                                                                                                                                                                              • Signs a request with the Authentication header.

                                                                                                                                                                                                                                                                                                Parameter webResource

                                                                                                                                                                                                                                                                                                The WebResourceLike/request to be signed.

                                                                                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                                                                                {Promise} The signed request object;

                                                                                                                                                                                                                                                                                              interface ServiceClientOptions

                                                                                                                                                                                                                                                                                              interface ServiceClientOptions {}
                                                                                                                                                                                                                                                                                              • Options to be provided while creating the client.

                                                                                                                                                                                                                                                                                              property agentSettings

                                                                                                                                                                                                                                                                                              agentSettings?: AgentSettings;
                                                                                                                                                                                                                                                                                              • HTTP and HTTPS agents which will be used for every HTTP request (Node.js only).

                                                                                                                                                                                                                                                                                              property baseUri

                                                                                                                                                                                                                                                                                              baseUri?: string;
                                                                                                                                                                                                                                                                                              • If specified: - This baseUri becomes the base URI that requests will be made against for this ServiceClient. - If the baseUri matches a known resource manager endpoint and if a TokenCredential was passed through the constructor, this baseUri defines the getToken scope to be ${options.baseUri}/.default. Otherwise, the scope would default to "https://management.azure.com/.default".

                                                                                                                                                                                                                                                                                                If it is not specified: - All OperationSpecs must contain a baseUrl property. - If a TokenCredential was passed through the constructor, the getToken scope is set to be "https://management.azure.com/.default".

                                                                                                                                                                                                                                                                                              property clientRequestIdHeaderName

                                                                                                                                                                                                                                                                                              clientRequestIdHeaderName?: string;
                                                                                                                                                                                                                                                                                              • If specified, a GenerateRequestIdPolicy will be added to the HTTP pipeline that will add a header to all outgoing requests with this header name and a random UUID as the request ID.

                                                                                                                                                                                                                                                                                              property deserializationContentTypes

                                                                                                                                                                                                                                                                                              deserializationContentTypes?: DeserializationContentTypes;
                                                                                                                                                                                                                                                                                              • The content-types that will be associated with JSON or XML serialization.

                                                                                                                                                                                                                                                                                              property generateClientRequestIdHeader

                                                                                                                                                                                                                                                                                              generateClientRequestIdHeader?: boolean;
                                                                                                                                                                                                                                                                                              • Whether or not to generate a client request ID header for each HTTP request.

                                                                                                                                                                                                                                                                                              property httpClient

                                                                                                                                                                                                                                                                                              httpClient?: HttpClient;
                                                                                                                                                                                                                                                                                              • The HttpClient that will be used to send HTTP requests.

                                                                                                                                                                                                                                                                                              property httpPipelineLogger

                                                                                                                                                                                                                                                                                              httpPipelineLogger?: HttpPipelineLogger;
                                                                                                                                                                                                                                                                                              • The HttpPipelineLogger that can be used to debug RequestPolicies within the HTTP pipeline.

                                                                                                                                                                                                                                                                                              property noRetryPolicy

                                                                                                                                                                                                                                                                                              noRetryPolicy?: boolean;
                                                                                                                                                                                                                                                                                              • If set to true, turn off the default retry policy.

                                                                                                                                                                                                                                                                                              property proxySettings

                                                                                                                                                                                                                                                                                              proxySettings?: ProxySettings;
                                                                                                                                                                                                                                                                                              • Proxy settings which will be used for every HTTP request (Node.js only).

                                                                                                                                                                                                                                                                                              property redirectOptions

                                                                                                                                                                                                                                                                                              redirectOptions?: RedirectOptions;
                                                                                                                                                                                                                                                                                              • Options for how redirect responses are handled.

                                                                                                                                                                                                                                                                                              property requestPolicyFactories

                                                                                                                                                                                                                                                                                              requestPolicyFactories?:
                                                                                                                                                                                                                                                                                              | RequestPolicyFactory[]
                                                                                                                                                                                                                                                                                              | ((
                                                                                                                                                                                                                                                                                              defaultRequestPolicyFactories: RequestPolicyFactory[]
                                                                                                                                                                                                                                                                                              ) => void | RequestPolicyFactory[]);
                                                                                                                                                                                                                                                                                              • An array of factories which get called to create the RequestPolicy pipeline used to send a HTTP request on the wire, or a function that takes in the defaultRequestPolicyFactories and returns the requestPolicyFactories that will be used.

                                                                                                                                                                                                                                                                                              property rpRegistrationRetryTimeout

                                                                                                                                                                                                                                                                                              rpRegistrationRetryTimeout?: number;
                                                                                                                                                                                                                                                                                              • Gets or sets the retry timeout in seconds for AutomaticRPRegistration. Default value is 30.

                                                                                                                                                                                                                                                                                              property userAgent

                                                                                                                                                                                                                                                                                              userAgent?: string | ((defaultUserAgent: string) => string);
                                                                                                                                                                                                                                                                                              • The string to be set to the telemetry header while sending the request, or a function that takes in the default user-agent string and returns the user-agent string that will be used.

                                                                                                                                                                                                                                                                                              property userAgentHeaderName

                                                                                                                                                                                                                                                                                              userAgentHeaderName?: string | ((defaultUserAgentHeaderName: string) => string);
                                                                                                                                                                                                                                                                                              • The header name to use for the telemetry header while sending the request. If this is not specified, then "User-Agent" will be used when running on Node.js and "x-ms-command-name" will be used when running in a browser.

                                                                                                                                                                                                                                                                                              property withCredentials

                                                                                                                                                                                                                                                                                              withCredentials?: boolean;
                                                                                                                                                                                                                                                                                              • Whether to include credentials in CORS requests in the browser. See https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials for more information.

                                                                                                                                                                                                                                                                                              interface SimpleMapperType

                                                                                                                                                                                                                                                                                              interface SimpleMapperType {}

                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                name:
                                                                                                                                                                                                                                                                                                | 'Base64Url'
                                                                                                                                                                                                                                                                                                | 'Boolean'
                                                                                                                                                                                                                                                                                                | 'ByteArray'
                                                                                                                                                                                                                                                                                                | 'Date'
                                                                                                                                                                                                                                                                                                | 'DateTime'
                                                                                                                                                                                                                                                                                                | 'DateTimeRfc1123'
                                                                                                                                                                                                                                                                                                | 'Object'
                                                                                                                                                                                                                                                                                                | 'Stream'
                                                                                                                                                                                                                                                                                                | 'String'
                                                                                                                                                                                                                                                                                                | 'TimeSpan'
                                                                                                                                                                                                                                                                                                | 'UnixTime'
                                                                                                                                                                                                                                                                                                | 'Uuid'
                                                                                                                                                                                                                                                                                                | 'Number'
                                                                                                                                                                                                                                                                                                | 'any';

                                                                                                                                                                                                                                                                                                  interface UrlParameterValue

                                                                                                                                                                                                                                                                                                  interface UrlParameterValue {}

                                                                                                                                                                                                                                                                                                    property skipUrlEncoding

                                                                                                                                                                                                                                                                                                    skipUrlEncoding: boolean;

                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                      value: string;

                                                                                                                                                                                                                                                                                                        interface WebResourceLike

                                                                                                                                                                                                                                                                                                        interface WebResourceLike {}
                                                                                                                                                                                                                                                                                                        • An abstraction over a REST call.

                                                                                                                                                                                                                                                                                                        property abortSignal

                                                                                                                                                                                                                                                                                                        abortSignal?: AbortSignalLike;
                                                                                                                                                                                                                                                                                                        • Used to abort the request later.

                                                                                                                                                                                                                                                                                                        property agentSettings

                                                                                                                                                                                                                                                                                                        agentSettings?: AgentSettings;
                                                                                                                                                                                                                                                                                                        • HTTP(S) agent configuration.

                                                                                                                                                                                                                                                                                                        property body

                                                                                                                                                                                                                                                                                                        body?: any;
                                                                                                                                                                                                                                                                                                        • The HTTP body contents of the request.

                                                                                                                                                                                                                                                                                                        property formData

                                                                                                                                                                                                                                                                                                        formData?: any;

                                                                                                                                                                                                                                                                                                          property headers

                                                                                                                                                                                                                                                                                                          headers: HttpHeadersLike;
                                                                                                                                                                                                                                                                                                          • The HTTP headers to use when making the request.

                                                                                                                                                                                                                                                                                                          property keepAlive

                                                                                                                                                                                                                                                                                                          keepAlive?: boolean;
                                                                                                                                                                                                                                                                                                          • If the connection should be reused.

                                                                                                                                                                                                                                                                                                          property method

                                                                                                                                                                                                                                                                                                          method: HttpMethods;
                                                                                                                                                                                                                                                                                                          • The HTTP method to use when making the request.

                                                                                                                                                                                                                                                                                                          property onDownloadProgress

                                                                                                                                                                                                                                                                                                          onDownloadProgress?: (progress: TransferProgressEvent) => void;
                                                                                                                                                                                                                                                                                                          • Callback which fires upon download progress.

                                                                                                                                                                                                                                                                                                          property onUploadProgress

                                                                                                                                                                                                                                                                                                          onUploadProgress?: (progress: TransferProgressEvent) => void;
                                                                                                                                                                                                                                                                                                          • Callback which fires upon upload progress.

                                                                                                                                                                                                                                                                                                          property operationResponseGetter

                                                                                                                                                                                                                                                                                                          operationResponseGetter?: (
                                                                                                                                                                                                                                                                                                          operationSpec: OperationSpec,
                                                                                                                                                                                                                                                                                                          response: HttpOperationResponse
                                                                                                                                                                                                                                                                                                          ) => undefined | OperationResponse;
                                                                                                                                                                                                                                                                                                          • A function that returns the proper OperationResponse for the given OperationSpec and HttpOperationResponse combination. If this is undefined, then a simple status code lookup will be used.

                                                                                                                                                                                                                                                                                                          property operationSpec

                                                                                                                                                                                                                                                                                                          operationSpec?: OperationSpec;
                                                                                                                                                                                                                                                                                                          • Used to parse the response.

                                                                                                                                                                                                                                                                                                          property proxySettings

                                                                                                                                                                                                                                                                                                          proxySettings?: ProxySettings;
                                                                                                                                                                                                                                                                                                          • Proxy configuration.

                                                                                                                                                                                                                                                                                                          property query

                                                                                                                                                                                                                                                                                                          query?: {
                                                                                                                                                                                                                                                                                                          [key: string]: any;
                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                          • A query string represented as an object.

                                                                                                                                                                                                                                                                                                          property redirectLimit

                                                                                                                                                                                                                                                                                                          redirectLimit?: number;
                                                                                                                                                                                                                                                                                                          • Limit the number of redirects followed for this request. If set to 0, redirects will not be followed. If left undefined the default redirect behaviour of the underlying node_fetch will apply.

                                                                                                                                                                                                                                                                                                          property shouldDeserialize

                                                                                                                                                                                                                                                                                                          shouldDeserialize?: boolean | ((response: HttpOperationResponse) => boolean);
                                                                                                                                                                                                                                                                                                          • Whether or not the HttpOperationResponse should be deserialized. If this is undefined, then the HttpOperationResponse should be deserialized.

                                                                                                                                                                                                                                                                                                          property streamResponseBody

                                                                                                                                                                                                                                                                                                          streamResponseBody?: boolean;
                                                                                                                                                                                                                                                                                                          • Whether or not the body of the HttpOperationResponse should be treated as a stream.

                                                                                                                                                                                                                                                                                                          property timeout

                                                                                                                                                                                                                                                                                                          timeout: number;
                                                                                                                                                                                                                                                                                                          • The number of milliseconds a request can take before automatically being terminated. If the request is terminated, an AbortError is thrown.

                                                                                                                                                                                                                                                                                                          property url

                                                                                                                                                                                                                                                                                                          url: string;
                                                                                                                                                                                                                                                                                                          • The URL being accessed by the request.

                                                                                                                                                                                                                                                                                                          property withCredentials

                                                                                                                                                                                                                                                                                                          withCredentials: boolean;
                                                                                                                                                                                                                                                                                                          • If credentials (cookies) should be sent along during an XHR.

                                                                                                                                                                                                                                                                                                          method clone

                                                                                                                                                                                                                                                                                                          clone: () => WebResourceLike;
                                                                                                                                                                                                                                                                                                          • Clone this request object.

                                                                                                                                                                                                                                                                                                          method prepare

                                                                                                                                                                                                                                                                                                          prepare: (options: RequestPrepareOptions) => WebResourceLike;
                                                                                                                                                                                                                                                                                                          • Sets options on the request.

                                                                                                                                                                                                                                                                                                          method validateRequestProperties

                                                                                                                                                                                                                                                                                                          validateRequestProperties: () => void;
                                                                                                                                                                                                                                                                                                          • Validates that the required properties such as method, url, headers["Content-Type"], headers["accept-language"] are defined. It will throw an error if one of the above mentioned properties are not defined.

                                                                                                                                                                                                                                                                                                          Enums

                                                                                                                                                                                                                                                                                                          enum HttpPipelineLogLevel

                                                                                                                                                                                                                                                                                                          enum HttpPipelineLogLevel {
                                                                                                                                                                                                                                                                                                          OFF = 0,
                                                                                                                                                                                                                                                                                                          ERROR = 1,
                                                                                                                                                                                                                                                                                                          WARNING = 2,
                                                                                                                                                                                                                                                                                                          INFO = 3,
                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                          • The different levels of logs that can be used with the HttpPipelineLogger.

                                                                                                                                                                                                                                                                                                          member ERROR

                                                                                                                                                                                                                                                                                                          ERROR = 1
                                                                                                                                                                                                                                                                                                          • An error log.

                                                                                                                                                                                                                                                                                                          member INFO

                                                                                                                                                                                                                                                                                                          INFO = 3
                                                                                                                                                                                                                                                                                                          • An information log.

                                                                                                                                                                                                                                                                                                          member OFF

                                                                                                                                                                                                                                                                                                          OFF = 0
                                                                                                                                                                                                                                                                                                          • A log level that indicates that no logs will be logged.

                                                                                                                                                                                                                                                                                                          member WARNING

                                                                                                                                                                                                                                                                                                          WARNING = 2
                                                                                                                                                                                                                                                                                                          • A warning log.

                                                                                                                                                                                                                                                                                                          enum QueryCollectionFormat

                                                                                                                                                                                                                                                                                                          enum QueryCollectionFormat {
                                                                                                                                                                                                                                                                                                          Csv = ',',
                                                                                                                                                                                                                                                                                                          Ssv = ' ',
                                                                                                                                                                                                                                                                                                          Tsv = '\t',
                                                                                                                                                                                                                                                                                                          Pipes = '|',
                                                                                                                                                                                                                                                                                                          Multi = 'Multi',
                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                          • The format that will be used to join an array of values together for a query parameter value.

                                                                                                                                                                                                                                                                                                          member Csv

                                                                                                                                                                                                                                                                                                          Csv = ','

                                                                                                                                                                                                                                                                                                            member Multi

                                                                                                                                                                                                                                                                                                            Multi = 'Multi'

                                                                                                                                                                                                                                                                                                              member Pipes

                                                                                                                                                                                                                                                                                                              Pipes = '|'

                                                                                                                                                                                                                                                                                                                member Ssv

                                                                                                                                                                                                                                                                                                                Ssv = ' '

                                                                                                                                                                                                                                                                                                                  member Tsv

                                                                                                                                                                                                                                                                                                                  Tsv = '\t'

                                                                                                                                                                                                                                                                                                                    Type Aliases

                                                                                                                                                                                                                                                                                                                    type Authenticator

                                                                                                                                                                                                                                                                                                                    type Authenticator = (challenge: object) => Promise<string>;

                                                                                                                                                                                                                                                                                                                      type HttpMethods

                                                                                                                                                                                                                                                                                                                      type HttpMethods =
                                                                                                                                                                                                                                                                                                                      | 'GET'
                                                                                                                                                                                                                                                                                                                      | 'PUT'
                                                                                                                                                                                                                                                                                                                      | 'POST'
                                                                                                                                                                                                                                                                                                                      | 'DELETE'
                                                                                                                                                                                                                                                                                                                      | 'PATCH'
                                                                                                                                                                                                                                                                                                                      | 'HEAD'
                                                                                                                                                                                                                                                                                                                      | 'OPTIONS'
                                                                                                                                                                                                                                                                                                                      | 'TRACE';

                                                                                                                                                                                                                                                                                                                        type HttpRequestBody

                                                                                                                                                                                                                                                                                                                        type HttpRequestBody =
                                                                                                                                                                                                                                                                                                                        | Blob
                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                        | ArrayBuffer
                                                                                                                                                                                                                                                                                                                        | ArrayBufferView
                                                                                                                                                                                                                                                                                                                        | (() => NodeJS.ReadableStream);

                                                                                                                                                                                                                                                                                                                          type Mapper

                                                                                                                                                                                                                                                                                                                          type Mapper =
                                                                                                                                                                                                                                                                                                                          | BaseMapper
                                                                                                                                                                                                                                                                                                                          | CompositeMapper
                                                                                                                                                                                                                                                                                                                          | SequenceMapper
                                                                                                                                                                                                                                                                                                                          | DictionaryMapper
                                                                                                                                                                                                                                                                                                                          | EnumMapper;

                                                                                                                                                                                                                                                                                                                            type MapperType

                                                                                                                                                                                                                                                                                                                            type MapperType =
                                                                                                                                                                                                                                                                                                                            | SimpleMapperType
                                                                                                                                                                                                                                                                                                                            | CompositeMapperType
                                                                                                                                                                                                                                                                                                                            | SequenceMapperType
                                                                                                                                                                                                                                                                                                                            | DictionaryMapperType
                                                                                                                                                                                                                                                                                                                            | EnumMapperType;

                                                                                                                                                                                                                                                                                                                              type RequestPolicyFactory

                                                                                                                                                                                                                                                                                                                              type RequestPolicyFactory = {
                                                                                                                                                                                                                                                                                                                              create(
                                                                                                                                                                                                                                                                                                                              nextPolicy: RequestPolicy,
                                                                                                                                                                                                                                                                                                                              options: RequestPolicyOptionsLike
                                                                                                                                                                                                                                                                                                                              ): RequestPolicy;
                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                              • Creates a new RequestPolicy per-request that uses the provided nextPolicy.

                                                                                                                                                                                                                                                                                                                              type TransferProgressEvent

                                                                                                                                                                                                                                                                                                                              type TransferProgressEvent = {
                                                                                                                                                                                                                                                                                                                              /**
                                                                                                                                                                                                                                                                                                                              * The number of bytes loaded so far.
                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                              loadedBytes: number;
                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                              • Fired in response to upload or download progress.

                                                                                                                                                                                                                                                                                                                              Package Files (39)

                                                                                                                                                                                                                                                                                                                              Dependencies (9)

                                                                                                                                                                                                                                                                                                                              Dev Dependencies (63)

                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@azure/ms-rest-js.

                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@azure/ms-rest-js)
                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@azure/ms-rest-js"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>