@azure/cosmos/dist/types/latest/cosmos.d.ts

import { AbortError } from '@azure/abort-controller';
import type { HttpClient } from '@azure/core-rest-pipeline';
import type { Pipeline } from '@azure/core-rest-pipeline';
import { RestError } from '@azure/core-rest-pipeline';
import type { TokenCredential } from '@azure/core-auth';

export { AbortError }

export declare interface Agent {
    maxFreeSockets: number;
    maxSockets: number;
    sockets: any;
    requests: any;
    destroy(): void;
}

export declare type AggregateType = "Average" | "Count" | "Max" | "Min" | "Sum" | "MakeSet" | "MakeList";

export declare type BulkOperationResponse = OperationResponse[] & {
    diagnostics: CosmosDiagnostics;
};

export declare const BulkOperationType: {
    readonly Create: "Create";
    readonly Upsert: "Upsert";
    readonly Read: "Read";
    readonly Delete: "Delete";
    readonly Replace: "Replace";
    readonly Patch: "Patch";
};

/**
 * Options object used to modify bulk execution.
 * continueOnError (Default value: false) - Continues bulk execution when an operation fails ** NOTE THIS WILL DEFAULT TO TRUE IN the 4.0 RELEASE
 */
export declare interface BulkOptions {
    continueOnError?: boolean;
}

export declare type BulkPatchOperation = OperationBase & {
    operationType: typeof BulkOperationType.Patch;
    id: string;
};

/**
 * Provides iterator for change feed.
 *
 * Use `Items.changeFeed()` to get an instance of the iterator.
 */
export declare class ChangeFeedIterator<T> {
    private clientContext;
    private resourceId;
    private resourceLink;
    private partitionKey;
    private changeFeedOptions;
    private static readonly IfNoneMatchAllHeaderValue;
    private nextIfNoneMatch;
    private ifModifiedSince;
    private lastStatusCode;
    private isPartitionSpecified;
    /**
     * Gets a value indicating whether there are potentially additional results that can be retrieved.
     *
     * Initially returns true. This value is set based on whether the last execution returned a continuation token.
     *
     * @returns Boolean value representing if whether there are potentially additional results that can be retrieved.
     */
    get hasMoreResults(): boolean;
    /**
     * Gets an async iterator which will yield pages of results from Azure Cosmos DB.
     */
    getAsyncIterator(): AsyncIterable<ChangeFeedResponse<Array<T & Resource>>>;
    /**
     * Read feed and retrieves the next page of results in Azure Cosmos DB.
     */
    fetchNext(): Promise<ChangeFeedResponse<Array<T & Resource>>>;
    private getFeedResponse;
}

/**
 * Specifies options for the change feed
 *
 * If none of those options are set, it will start reading changes from now for the entire container.
 */
export declare interface ChangeFeedIteratorOptions {
    /**
     * Max amount of items to return per page
     */
    maxItemCount?: number;
    /**
     * The session token to use. If not specified, will use the most recent captured session token to start with.
     */
    sessionToken?: string;
    /**
     * Signals where to start from in the change feed.
     */
    changeFeedStartFrom?: ChangeFeedStartFrom;
    /**
     * Signals the mode in which the change feed needs to start.
     */
    changeFeedMode?: ChangeFeedMode;
}

/**
 * A single response page from the Azure Cosmos DB Change Feed
 */
export declare class ChangeFeedIteratorResponse<T> {
    /**
     * Gets the items returned in the response from Azure Cosmos DB
     */
    readonly result: T;
    /**
     * Gets the number of items returned in the response from Azure Cosmos DB
     */
    readonly count: number;
    /**
     * Gets the status code of the response from Azure Cosmos DB
     */
    readonly statusCode: number;
    /**
     * Cosmos Diagnostic Object.
     */
    readonly diagnostics: CosmosDiagnostics;
    /**
     * Gets the subStatusCodes of the response from Azure Cosmos DB. Useful in partition split or partition gone.
     */
    readonly subStatusCode?: number;
    /**
     * Gets the request charge for this request from the Azure Cosmos DB service.
     */
    get requestCharge(): number;
    /**
     * Gets the activity ID for the request from the Azure Cosmos DB service.
     */
    get activityId(): string;
    /**
     * Gets the continuation token to be used for continuing enumeration of the Azure Cosmos DB service.
     */
    get continuationToken(): string;
    /**
     * Gets the session token for use in session consistency reads from the Azure Cosmos DB service.
     */
    get sessionToken(): string;
    /**
     * Response headers of the response from Azure Cosmos DB
     */
    headers: CosmosHeaders;
}

export declare enum ChangeFeedMode {
    LatestVersion = "Incremental Feed",
    AllVersionsAndDeletes = "Full-Fidelity Feed"
}

/**
 * Specifies options for the change feed
 *
 * Some of these options control where and when to start reading from the change feed. The order of precedence is:
 * - continuation
 * - startTime
 * - startFromBeginning
 *
 * If none of those options are set, it will start reading changes from the first `ChangeFeedIterator.fetchNext()` call.
 */
export declare interface ChangeFeedOptions {
    /**
     * Max amount of items to return per page
     */
    maxItemCount?: number;
    /**
     * The continuation token to start from.
     *
     * This is equivalent to the etag and continuation value from the `ChangeFeedResponse`
     */
    continuation?: string;
    /**
     * The session token to use. If not specified, will use the most recent captured session token to start with.
     */
    sessionToken?: string;
    /**
     * Signals whether to start from the beginning or not.
     */
    startFromBeginning?: boolean;
    /**
     * Specified the start time to start reading changes from.
     */
    startTime?: Date;
}

/**
 * Represents the change feed policy configuration for a container in the Azure Cosmos DB service.
 */
export declare class ChangeFeedPolicy {
    retentionDuration: number;
    constructor(retentionDuration: ChangeFeedRetentionTimeSpan);
}

/**
 * Use `Items.getChangeFeedIterator()` to return an iterator that can iterate over all the changes for a partition key, feed range or an entire container.
 */
export declare interface ChangeFeedPullModelIterator<T> {
    /**
     * Always returns true, changefeed is an infinite stream.
     */
    readonly hasMoreResults: boolean;
    /**
     * Returns next set of results for the change feed.
     */
    readNext(): Promise<ChangeFeedIteratorResponse<Array<T & Resource>>>;
    /**
     * Gets an async iterator which will yield change feed results.
     * @example Get changefeed for an entire container from now
     * ```typescript
     * const options = { changeFeedStartFrom: ChangeFeedStartFrom.Now() };
     * for await(const res of container.items.getChangeFeedIterator(options).getAsyncIterator()) {
     *   //process res
     * }
     * ```
     */
    getAsyncIterator(): AsyncIterable<ChangeFeedIteratorResponse<Array<T & Resource>>>;
}

/**
 * A single response page from the Azure Cosmos DB Change Feed
 */
export declare class ChangeFeedResponse<T> {
    /**
     * Gets the items returned in the response from Azure Cosmos DB
     */
    readonly result: T;
    /**
     * Gets the number of items returned in the response from Azure Cosmos DB
     */
    readonly count: number;
    /**
     * Gets the status code of the response from Azure Cosmos DB
     */
    readonly statusCode: number;
    readonly diagnostics: CosmosDiagnostics;
    /**
     * Gets the request charge for this request from the Azure Cosmos DB service.
     */
    get requestCharge(): number;
    /**
     * Gets the activity ID for the request from the Azure Cosmos DB service.
     */
    get activityId(): string;
    /**
     * Gets the continuation token to be used for continuing enumeration of the Azure Cosmos DB service.
     *
     * This is equivalent to the `etag` property.
     */
    get continuation(): string;
    /**
     * Gets the session token for use in session consistency reads from the Azure Cosmos DB service.
     */
    get sessionToken(): string;
    /**
     * Gets the entity tag associated with last transaction in the Azure Cosmos DB service,
     * which can be used as If-Non-Match Access condition for ReadFeed REST request or
     * `continuation` property of `ChangeFeedOptions` parameter for
     * `Items.changeFeed()`
     * to get feed changes since the transaction specified by this entity tag.
     *
     * This is equivalent to the `continuation` property.
     */
    get etag(): string;
    /**
     * Response headers of the response from Azure Cosmos DB
     */
    headers: CosmosHeaders;
}

export declare class ChangeFeedRetentionTimeSpan {
    private retentionInMinutes;
    /**
     * Specifies the retention window in minutes for which processing the change feed with allVersionsAndDeletes mode will be available.
     */
    static fromMinutes(minutes: number): ChangeFeedRetentionTimeSpan;
}

/**
 * Base class for where to start a ChangeFeedIterator.
 */
export declare abstract class ChangeFeedStartFrom {
    /**
     * Returns an object that tells the ChangeFeedIterator to start from the beginning of time.
     * @param cfResource - PartitionKey or FeedRange for which changes are to be fetched. Leave blank for fetching changes for entire container.
     */
    static Beginning(cfResource?: PartitionKey | FeedRange): ChangeFeedStartFromBeginning;
    /**
     *  Returns an object that tells the ChangeFeedIterator to start reading changes from this moment onward.
     * @param cfResource - PartitionKey or FeedRange for which changes are to be fetched. Leave blank for fetching changes for entire container.
     **/
    static Now(cfResource?: PartitionKey | FeedRange): ChangeFeedStartFromNow;
    /**
     * Returns an object that tells the ChangeFeedIterator to start reading changes from some point in time onward.
     * @param startTime - Date object specfiying the time to start reading changes from.
     * @param cfResource - PartitionKey or FeedRange for which changes are to be fetched. Leave blank for fetching changes for entire container.
     */
    static Time(startTime: Date, cfResource?: PartitionKey | FeedRange): ChangeFeedStartFromTime;
    /**
     * Returns an object that tells the ChangeFeedIterator to start reading changes from a save point.
     * @param continuation - The continuation to resume from.
     */
    static Continuation(continuationToken: string): ChangeFeedStartFromContinuation;
}

/**
 * @hidden
 * Class which specifies the ChangeFeedIterator to start reading changes from beginning of time.
 */
declare class ChangeFeedStartFromBeginning {
    private cfResource?;
    constructor(cfResource?: PartitionKey | FeedRange);
    getCfResource(): PartitionKey | FeedRange | undefined;
}

/**
 * @hidden
 * Class which specifies the ChangeFeedIterator to start reading changes from a saved point.
 */
declare class ChangeFeedStartFromContinuation {
    private continuationToken;
    constructor(continuation: string);
    getCfResource(): string;
    getCfResourceJson(): any;
    getResourceType(): any;
}

/**
 * @hidden
 * Class which specifies the ChangeFeedIterator to start reading changes from this moment in time.
 */
declare class ChangeFeedStartFromNow {
    cfResource?: PartitionKey | FeedRange;
    constructor(cfResource?: PartitionKey | FeedRange);
    getCfResource(): PartitionKey | FeedRange | undefined;
}

/**
 * @hidden
 * Class which specifies the ChangeFeedIterator to start reading changes from a particular point of time.
 */
declare class ChangeFeedStartFromTime {
    private cfResource?;
    private startTime;
    constructor(startTime: Date, cfResource?: PartitionKey | FeedRange);
    getCfResource(): PartitionKey | FeedRange | undefined;
    getStartTime(): Date;
}

/**
 * This type holds information related to initialization of `CosmosClient`
 */
export declare type ClientConfigDiagnostic = {
    /**
     * End point configured during client initialization.
     */
    endpoint: string;
    /**
     * True if `resourceTokens` was supplied during client initialization.
     */
    resourceTokensConfigured: boolean;
    /**
     * True if `tokenProvider` was supplied during client initialization.
     */
    tokenProviderConfigured: boolean;
    /**
     * True if `aadCredentials` was supplied during client initialization.
     */
    aadCredentialsConfigured: boolean;
    /**
     * True if `connectionPolicy` was supplied during client initialization.
     */
    connectionPolicyConfigured: boolean;
    /**
     * `consistencyLevel` supplied during client initialization.
     */
    consistencyLevel?: keyof typeof ConsistencyLevel;
    /**
     * `defaultHeaders` supplied during client initialization.
     */
    defaultHeaders?: {
        [key: string]: any;
    };
    /**
     * True if `connectionPolicy` were supplied during client initialization.
     */
    agentConfigured: boolean;
    /**
     * `userAgentSuffix` supplied during client initialization.
     */
    userAgentSuffix: string;
    /**
     * `diagnosticLevel` supplied during client initialization.
     */
    diagnosticLevel?: CosmosDbDiagnosticLevel;
    /**
     * True if `plugins` were supplied during client initialization.
     */
    pluginsConfigured: boolean;
    /**
     * SDK version
     */
    sDKVersion: string;
};

/**
 * @hidden
 * @hidden
 */
export declare class ClientContext {
    private cosmosClientOptions;
    private globalEndpointManager;
    private clientConfig;
    diagnosticLevel: CosmosDbDiagnosticLevel;
    private readonly sessionContainer;
    private connectionPolicy;
    private pipeline;
    private diagnosticWriter;
    private diagnosticFormatter;
    partitionKeyDefinitionCache: {
        [containerUrl: string]: any;
    };
    constructor(cosmosClientOptions: CosmosClientOptions, globalEndpointManager: GlobalEndpointManager, clientConfig: ClientConfigDiagnostic, diagnosticLevel: CosmosDbDiagnosticLevel);
    /** @hidden */
    read<T>({ path, resourceType, resourceId, options, partitionKey, diagnosticNode, }: {
        path: string;
        resourceType: ResourceType;
        resourceId: string;
        options?: RequestOptions;
        partitionKey?: PartitionKey;
        diagnosticNode: DiagnosticNodeInternal;
    }): Promise<Response_2<T & Resource>>;
    queryFeed<T>({ path, resourceType, resourceId, resultFn, query, options, diagnosticNode, partitionKeyRangeId, partitionKey, startEpk, endEpk, correlatedActivityId, }: {
        path: string;
        resourceType: ResourceType;
        resourceId: string;
        resultFn: (result: {
            [key: string]: any;
        }) => any[];
        query: SqlQuerySpec | string;
        options: FeedOptions;
        diagnosticNode: DiagnosticNodeInternal;
        partitionKeyRangeId?: string;
        partitionKey?: PartitionKey;
        startEpk?: string | undefined;
        endEpk?: string | undefined;
        correlatedActivityId?: string;
    }): Promise<Response_2<T & Resource>>;
    getQueryPlan(path: string, resourceType: ResourceType, resourceId: string, query: SqlQuerySpec | string, options: FeedOptions, diagnosticNode: DiagnosticNodeInternal, correlatedActivityId?: string): Promise<Response_2<PartitionedQueryExecutionInfo>>;
    queryPartitionKeyRanges(collectionLink: string, query?: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<PartitionKeyRange>;
    delete<T>({ path, resourceType, resourceId, options, partitionKey, method, diagnosticNode, }: {
        path: string;
        resourceType: ResourceType;
        resourceId: string;
        options?: RequestOptions;
        partitionKey?: PartitionKey;
        method?: HTTPMethod;
        diagnosticNode: DiagnosticNodeInternal;
    }): Promise<Response_2<T & Resource>>;
    patch<T>({ body, path, resourceType, resourceId, options, partitionKey, diagnosticNode, }: {
        body: any;
        path: string;
        resourceType: ResourceType;
        resourceId: string;
        options?: RequestOptions;
        partitionKey?: PartitionKey;
        diagnosticNode: DiagnosticNodeInternal;
    }): Promise<Response_2<T & Resource>>;
    create<T, U = T>({ body, path, resourceType, resourceId, diagnosticNode, options, partitionKey, }: {
        body: T;
        path: string;
        resourceType: ResourceType;
        resourceId: string;
        diagnosticNode: DiagnosticNodeInternal;
        options?: RequestOptions;
        partitionKey?: PartitionKey;
    }): Promise<Response_2<T & U & Resource>>;
    private processQueryFeedResponse;
    private applySessionToken;
    replace<T>({ body, path, resourceType, resourceId, options, partitionKey, diagnosticNode, }: {
        body: any;
        path: string;
        resourceType: ResourceType;
        resourceId: string;
        options?: RequestOptions;
        partitionKey?: PartitionKey;
        diagnosticNode: DiagnosticNodeInternal;
    }): Promise<Response_2<T & Resource>>;
    upsert<T, U = T>({ body, path, resourceType, resourceId, options, partitionKey, diagnosticNode, }: {
        body: T;
        path: string;
        resourceType: ResourceType;
        resourceId: string;
        options?: RequestOptions;
        partitionKey?: PartitionKey;
        diagnosticNode: DiagnosticNodeInternal;
    }): Promise<Response_2<T & U & Resource>>;
    execute<T>({ sprocLink, params, options, partitionKey, diagnosticNode, }: {
        sprocLink: string;
        params?: any[];
        options?: RequestOptions;
        partitionKey?: PartitionKey;
        diagnosticNode: DiagnosticNodeInternal;
    }): Promise<Response_2<T>>;
    /**
     * Gets the Database account information.
     * @param options - `urlConnection` in the options is the endpoint url whose database account needs to be retrieved.
     * If not present, current client's url will be used.
     */
    getDatabaseAccount(diagnosticNode: DiagnosticNodeInternal, options?: RequestOptions): Promise<Response_2<DatabaseAccount>>;
    getWriteEndpoint(diagnosticNode: DiagnosticNodeInternal): Promise<string>;
    getReadEndpoint(diagnosticNode: DiagnosticNodeInternal): Promise<string>;
    getWriteEndpoints(): Promise<readonly string[]>;
    getReadEndpoints(): Promise<readonly string[]>;
    batch<T>({ body, path, partitionKey, resourceId, options, diagnosticNode, }: {
        body: T;
        path: string;
        partitionKey: PartitionKey;
        resourceId: string;
        options?: RequestOptions;
        diagnosticNode: DiagnosticNodeInternal;
    }): Promise<Response_2<any>>;
    bulk<T>({ body, path, partitionKeyRangeId, resourceId, bulkOptions, options, diagnosticNode, }: {
        body: T;
        path: string;
        partitionKeyRangeId: string;
        resourceId: string;
        bulkOptions?: BulkOptions;
        options?: RequestOptions;
        diagnosticNode: DiagnosticNodeInternal;
    }): Promise<Response_2<any>>;
    private captureSessionToken;
    clearSessionToken(path: string): void;
    recordDiagnostics(diagnostic: CosmosDiagnostics): void;
    initializeDiagnosticSettings(diagnosticLevel: CosmosDbDiagnosticLevel): void;
    private getSessionParams;
    private isMasterResource;
    private buildHeaders;
    /**
     * Returns collection of properties which are derived from the context for Request Creation.
     * These properties have client wide scope, as opposed to request specific scope.
     * @returns
     */
    private getContextDerivedPropsForRequestCreation;
    getClientConfig(): ClientConfigDiagnostic;
}

export declare class ClientSideMetrics {
    readonly requestCharge: number;
    constructor(requestCharge: number);
    /**
     * Adds one or more ClientSideMetrics to a copy of this instance and returns the result.
     */
    add(...clientSideMetricsArray: ClientSideMetrics[]): ClientSideMetrics;
    static readonly zero: ClientSideMetrics;
    static createFromArray(...clientSideMetricsArray: ClientSideMetrics[]): ClientSideMetrics;
}

/**
 * This is a collection type for all client side diagnostic information.
 */
export declare type ClientSideRequestStatistics = {
    /**
     * This is the UTC timestamp for start of client operation.
     */
    requestStartTimeUTCInMs: number;
    /**
     * This is the duration in milli seconds taken by client operation.
     */
    requestDurationInMs: number;
    /**
     * This is the list of Location Endpoints contacted during the client operation.
     */
    locationEndpointsContacted: string[];
    /**
     * This field captures diagnostic information for retries happened during client operation.
     */
    retryDiagnostics: RetryDiagnostics;
    /**
     * This field captures diagnostic information for meta data lookups happened during client operation.
     */
    metadataDiagnostics: MetadataLookUpDiagnostics;
    /**
     * These are the statistics for main point look operation.
     */
    gatewayStatistics: GatewayStatistics[];
    /**
     * This is the cumulated Request Payload Length n bytes, this includes metadata calls along with the main operation.
     */
    totalRequestPayloadLengthInBytes: number;
    /**
     * This is the cumulated Response Payload Length n bytes, this includes metadata calls along with the main operation.
     */
    totalResponsePayloadLengthInBytes: number;
};

/**
 * Represents a composite path in the indexing policy.
 */
export declare interface CompositePath {
    /** The path in the JSON document to include in the composite index. */
    path: string;
    /** The order of the composite index, either "ascending" or "descending". */
    order: "ascending" | "descending";
}

export declare interface ComputedProperty {
    /**
     *  The name of the computed property. Name of the computed property
     *  should be chosen such that it does not collide with any existing
     *  or future document properties.
     */
    name: string;
    query: string;
    [key: string]: any;
}

/**
 * Use to read or delete a given {@link Conflict} by id.
 *
 * @see {@link Conflicts} to query or read all conflicts.
 */
export declare class Conflict {
    readonly container: Container;
    readonly id: string;
    private readonly clientContext;
    private partitionKey?;
    /**
     * Returns a reference URL to the resource. Used for linking in Permissions.
     */
    get url(): string;
    /**
     * @hidden
     * @param container - The parent {@link Container}.
     * @param id - The id of the given {@link Conflict}.
     */
    constructor(container: Container, id: string, clientContext: ClientContext, partitionKey?: PartitionKey);
    /**
     * Read the {@link ConflictDefinition} for the given {@link Conflict}.
     */
    read(options?: RequestOptions): Promise<ConflictResponse>;
    /**
     * Delete the given {@link ConflictDefinition}.
     */
    delete(options?: RequestOptions): Promise<ConflictResponse>;
}

export declare interface ConflictDefinition {
    /** The id of the conflict */
    id?: string;
    /** Source resource id */
    resourceId?: string;
    resourceType?: ResourceType;
    operationType?: OperationType;
    content?: string;
}

export declare enum ConflictResolutionMode {
    Custom = "Custom",
    LastWriterWins = "LastWriterWins"
}

/**
 * Represents the conflict resolution policy configuration for specifying how to resolve conflicts
 *  in case writes from different regions result in conflicts on documents in the collection in the Azure Cosmos DB service.
 */
export declare interface ConflictResolutionPolicy {
    /**
     * Gets or sets the <see cref="ConflictResolutionMode"/> in the Azure Cosmos DB service. By default it is {@link ConflictResolutionMode.LastWriterWins}.
     */
    mode?: keyof typeof ConflictResolutionMode;
    /**
     * Gets or sets the path which is present in each document in the Azure Cosmos DB service for last writer wins conflict-resolution.
     * This path must be present in each document and must be an integer value.
     * In case of a conflict occurring on a document, the document with the higher integer value in the specified path will be picked.
     * If the path is unspecified, by default the timestamp path will be used.
     *
     * This value should only be set when using {@link ConflictResolutionMode.LastWriterWins}.
     *
     * ```typescript
     * conflictResolutionPolicy.ConflictResolutionPath = "/name/first";
     * ```
     *
     */
    conflictResolutionPath?: string;
    /**
     * Gets or sets the {@link StoredProcedure} which is used for conflict resolution in the Azure Cosmos DB service.
     * This stored procedure may be created after the {@link Container} is created and can be changed as required.
     *
     * 1. This value should only be set when using {@link ConflictResolutionMode.Custom}.
     * 2. In case the stored procedure fails or throws an exception, the conflict resolution will default to registering conflicts in the conflicts feed.
     *
     * ```typescript
     * conflictResolutionPolicy.ConflictResolutionProcedure = "resolveConflict"
     * ```
     */
    conflictResolutionProcedure?: string;
}

export declare class ConflictResponse extends ResourceResponse<ConflictDefinition & Resource> {
    constructor(resource: ConflictDefinition & Resource, headers: CosmosHeaders, statusCode: number, conflict: Conflict, diagnostics: CosmosDiagnostics);
    /** A reference to the {@link Conflict} corresponding to the returned {@link ConflictDefinition}. */
    readonly conflict: Conflict;
}

/**
 * Use to query or read all conflicts.
 *
 * @see {@link Conflict} to read or delete a given {@link Conflict} by id.
 */
export declare class Conflicts {
    readonly container: Container;
    private readonly clientContext;
    constructor(container: Container, clientContext: ClientContext);
    /**
     * Queries all conflicts.
     * @param query - Query configuration for the operation. See {@link SqlQuerySpec} for more info on how to configure a query.
     * @param options - Use to set options like response page size, continuation tokens, etc.
     * @returns {@link QueryIterator} Allows you to return results in an array or iterate over them one at a time.
         */
     query(query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<any>;
     /**
      * Queries all conflicts.
      * @param query - Query configuration for the operation. See {@link SqlQuerySpec} for more info on how to configure a query.
      * @param options - Use to set options like response page size, continuation tokens, etc.
      * @returns {@link QueryIterator} Allows you to return results in an array or iterate over them one at a time.
          */
      query<T>(query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<T>;
      /**
       * Reads all conflicts
       * @param options - Use to set options like response page size, continuation tokens, etc.
       */
      readAll(options?: FeedOptions): QueryIterator<ConflictDefinition & Resource>;
     }

     /** Determines the connection behavior of the CosmosClient. Note, we currently only support Gateway Mode. */
     export declare enum ConnectionMode {
         /** Gateway mode talks to an intermediate gateway which handles the direct communication with your individual partitions. */
         Gateway = 0
     }

     /**
      * Represents the Connection policy associated with a CosmosClient in the Azure Cosmos DB database service.
      */
     export declare interface ConnectionPolicy {
         /** Determines which mode to connect to Cosmos with. (Currently only supports Gateway option) */
         connectionMode?: ConnectionMode;
         /** Request timeout (time to wait for response from network peer). Represented in milliseconds. */
         requestTimeout?: number;
         /**
          * Flag to enable/disable automatic redirecting of requests based on read/write operations. Default true.
          * Required to call client.dispose() when this is set to true after destroying the CosmosClient inside another process or in the browser.
          */
         enableEndpointDiscovery?: boolean;
         /** List of azure regions to be used as preferred locations for read requests. */
         preferredLocations?: string[];
         /** RetryOptions object which defines several configurable properties used during retry. */
         retryOptions?: RetryOptions;
         /**
          * The flag that enables writes on any locations (regions) for geo-replicated database accounts in the Azure Cosmos DB service.
          * Default is `false`.
          */
         useMultipleWriteLocations?: boolean;
         /** Rate in milliseconds at which the client will refresh the endpoints list in the background */
         endpointRefreshRateInMs?: number;
         /** Flag to enable/disable background refreshing of endpoints. Defaults to false.
          * Endpoint discovery using `enableEndpointsDiscovery` will still work for failed requests. */
         enableBackgroundEndpointRefreshing?: boolean;
     }

     /**
      * Represents the consistency levels supported for Azure Cosmos DB client operations.<br>
      * The requested ConsistencyLevel must match or be weaker than that provisioned for the database account.
      * Consistency levels.
      *
      * Consistency levels by order of strength are Strong, BoundedStaleness, Session, Consistent Prefix, and Eventual.
      *
      * See https://aka.ms/cosmos-consistency for more detailed documentation on Consistency Levels.
      */
     export declare enum ConsistencyLevel {
         /**
          * Strong Consistency guarantees that read operations always return the value that was last written.
          */
         Strong = "Strong",
         /**
          * Bounded Staleness guarantees that reads are not too out-of-date.
          * This can be configured based on number of operations (MaxStalenessPrefix) or time (MaxStalenessIntervalInSeconds).
          */
         BoundedStaleness = "BoundedStaleness",
         /**
          * Session Consistency guarantees monotonic reads (you never read old data, then new, then old again),
          * monotonic writes (writes are ordered) and read your writes (your writes are immediately visible to your reads)
          * within any single session.
          */
         Session = "Session",
         /**
          * Eventual Consistency guarantees that reads will return a subset of writes.
          * All writes will be eventually be available for reads.
          */
         Eventual = "Eventual",
         /**
          * ConsistentPrefix Consistency guarantees that reads will return some prefix of all writes with no gaps.
          * All writes will be eventually be available for reads.
          */
         ConsistentPrefix = "ConsistentPrefix"
     }

     /**
      * @hidden
      */
     export declare const Constants: {
         HttpHeaders: {
             Authorization: string;
             ETag: string;
             MethodOverride: string;
             Slug: string;
             ContentType: string;
             LastModified: string;
             ContentEncoding: string;
             CharacterSet: string;
             UserAgent: string;
             IfModifiedSince: string;
             IfMatch: string;
             IfNoneMatch: string;
             ContentLength: string;
             AcceptEncoding: string;
             KeepAlive: string;
             CacheControl: string;
             TransferEncoding: string;
             ContentLanguage: string;
             ContentLocation: string;
             ContentMd5: string;
             ContentRange: string;
             Accept: string;
             AcceptCharset: string;
             AcceptLanguage: string;
             IfRange: string;
             IfUnmodifiedSince: string;
             MaxForwards: string;
             ProxyAuthorization: string;
             AcceptRanges: string;
             ProxyAuthenticate: string;
             RetryAfter: string;
             SetCookie: string;
             WwwAuthenticate: string;
             Origin: string;
             Host: string;
             AccessControlAllowOrigin: string;
             AccessControlAllowHeaders: string;
             KeyValueEncodingFormat: string;
             WrapAssertionFormat: string;
             WrapAssertion: string;
             WrapScope: string;
             SimpleToken: string;
             HttpDate: string;
             Prefer: string;
             Location: string;
             Referer: string;
             A_IM: string;
             Query: string;
             IsQuery: string;
             IsQueryPlan: string;
             SupportedQueryFeatures: string;
             QueryVersion: string;
             Continuation: string;
             ContinuationToken: string;
             PageSize: string;
             ItemCount: string;
             ChangeFeedWireFormatVersion: string;
             ActivityId: string;
             CorrelatedActivityId: string;
             PreTriggerInclude: string;
             PreTriggerExclude: string;
             PostTriggerInclude: string;
             PostTriggerExclude: string;
             IndexingDirective: string;
             SessionToken: string;
             ConsistencyLevel: string;
             XDate: string;
             CollectionPartitionInfo: string;
             CollectionServiceInfo: string;
             RetryAfterInMilliseconds: string;
             RetryAfterInMs: string;
             IsFeedUnfiltered: string;
             ResourceTokenExpiry: string;
             EnableScanInQuery: string;
             EmitVerboseTracesInQuery: string;
             EnableCrossPartitionQuery: string;
             ParallelizeCrossPartitionQuery: string;
             ResponseContinuationTokenLimitInKB: string;
             PopulateQueryMetrics: string;
             QueryMetrics: string;
             PopulateIndexMetrics: string;
             IndexUtilization: string;
             Version: string;
             OwnerFullName: string;
             OwnerId: string;
             PartitionKey: string;
             PartitionKeyRangeID: string;
             StartEpk: string;
             EndEpk: string;
             ReadFeedKeyType: string;
             MaxEntityCount: string;
             CurrentEntityCount: string;
             CollectionQuotaInMb: string;
             CollectionCurrentUsageInMb: string;
             MaxMediaStorageUsageInMB: string;
             CurrentMediaStorageUsageInMB: string;
             RequestCharge: string;
             PopulateQuotaInfo: string;
             MaxResourceQuota: string;
             OfferType: string;
             OfferThroughput: string;
             AutoscaleSettings: string;
             DisableRUPerMinuteUsage: string;
             IsRUPerMinuteUsed: string;
             OfferIsRUPerMinuteThroughputEnabled: string;
             IndexTransformationProgress: string;
             LazyIndexingProgress: string;
             IsUpsert: string;
             SubStatus: string;
             EnableScriptLogging: string;
             ScriptLogResults: string;
             ALLOW_MULTIPLE_WRITES: string;
             IsBatchRequest: string;
             IsBatchAtomic: string;
             BatchContinueOnError: string;
             DedicatedGatewayPerRequestCacheStaleness: string;
             DedicatedGatewayPerRequestBypassCache: string;
             ForceRefresh: string;
             PriorityLevel: string;
         };
         WritableLocations: string;
         ReadableLocations: string;
         LocationUnavailableExpirationTimeInMs: number;
         ENABLE_MULTIPLE_WRITABLE_LOCATIONS: string;
         DefaultUnavailableLocationExpirationTimeMS: number;
         ThrottleRetryCount: string;
         ThrottleRetryWaitTimeInMs: string;
         CurrentVersion: string;
         AzureNamespace: string;
         AzurePackageName: string;
         SDKName: string;
         SDKVersion: string;
         CosmosDbDiagnosticLevelEnvVarName: string;
         DefaultMaxBulkRequestBodySizeInBytes: number;
         Quota: {
             CollectionSize: string;
         };
         Path: {
             Root: string;
             DatabasesPathSegment: string;
             CollectionsPathSegment: string;
             UsersPathSegment: string;
             DocumentsPathSegment: string;
             PermissionsPathSegment: string;
             StoredProceduresPathSegment: string;
             TriggersPathSegment: string;
             UserDefinedFunctionsPathSegment: string;
             ConflictsPathSegment: string;
             AttachmentsPathSegment: string;
             PartitionKeyRangesPathSegment: string;
             SchemasPathSegment: string;
             OffersPathSegment: string;
             TopologyPathSegment: string;
             DatabaseAccountPathSegment: string;
         };
         PartitionKeyRange: PartitionKeyRangePropertiesNames;
         QueryRangeConstants: {
             MinInclusive: string;
             MaxExclusive: string;
             min: string;
         };
         /**
          * @deprecated Use EffectivePartitionKeyConstants instead
          */
         EffectiveParitionKeyConstants: {
             MinimumInclusiveEffectivePartitionKey: string;
             MaximumExclusiveEffectivePartitionKey: string;
         };
         EffectivePartitionKeyConstants: {
             MinimumInclusiveEffectivePartitionKey: string;
             MaximumExclusiveEffectivePartitionKey: string;
         };
         AllVersionsAndDeletesChangeFeedWireFormatVersion: string;
         ChangeFeedIfNoneMatchStartFromNowHeader: string;
     };

     /**
      * Operations for reading, replacing, or deleting a specific, existing container by id.
      *
      * @see {@link Containers} for creating new containers, and reading/querying all containers; use `.containers`.
      *
      * Note: all these operations make calls against a fixed budget.
      * You should design your system such that these calls scale sublinearly with your application.
      * For instance, do not call `container(id).read()` before every single `item.read()` call, to ensure the container exists;
      * do this once on application start up.
      */
     export declare class Container {
         readonly database: Database;
         readonly id: string;
         private readonly clientContext;
         private $items;
         /**
          * Operations for creating new items, and reading/querying all items
          *
          * For reading, replacing, or deleting an existing item, use `.item(id)`.
          *
          * @example Create a new item
          * ```typescript
          * const {body: createdItem} = await container.items.create({id: "<item id>", properties: {}});
          * ```
          */
         get items(): Items;
         private $scripts;
         /**
          * All operations for Stored Procedures, Triggers, and User Defined Functions
          */
         get scripts(): Scripts;
         private $conflicts;
         /**
          * Operations for reading and querying conflicts for the given container.
          *
          * For reading or deleting a specific conflict, use `.conflict(id)`.
          */
         get conflicts(): Conflicts;
         /**
          * Returns a reference URL to the resource. Used for linking in Permissions.
          */
         get url(): string;
         /**
          * Returns a container instance. Note: You should get this from `database.container(id)`, rather than creating your own object.
          * @param database - The parent {@link Database}.
          * @param id - The id of the given container.
          * @hidden
          */
         constructor(database: Database, id: string, clientContext: ClientContext);
         /**
          * Used to read, replace, or delete a specific, existing {@link Item} by id.
          *
          * Use `.items` for creating new items, or querying/reading all items.
          *
          * @param id - The id of the {@link Item}.
          * @param partitionKeyValue - The value of the {@link Item} partition key
          * @example Replace an item
          * `const {body: replacedItem} = await container.item("<item id>", "<partition key value>").replace({id: "<item id>", title: "Updated post", authorID: 5});`
          */
         item(id: string, partitionKeyValue?: PartitionKey): Item;
         /**
          * Used to read, replace, or delete a specific, existing {@link Conflict} by id.
          *
          * Use `.conflicts` for creating new conflicts, or querying/reading all conflicts.
          * @param id - The id of the {@link Conflict}.
          */
         conflict(id: string, partitionKey?: PartitionKey): Conflict;
         /** Read the container's definition */
         read(options?: RequestOptions): Promise<ContainerResponse>;
         /**
          * @hidden
          */
         readInternal(diagnosticNode: DiagnosticNodeInternal, options?: RequestOptions): Promise<ContainerResponse>;
         /** Replace the container's definition */
         replace(body: ContainerDefinition, options?: RequestOptions): Promise<ContainerResponse>;
         /** Delete the container */
         delete(options?: RequestOptions): Promise<ContainerResponse>;
         /**
          * Gets the partition key definition first by looking into the cache otherwise by reading the collection.
          * @deprecated This method has been renamed to readPartitionKeyDefinition.
          */
         getPartitionKeyDefinition(): Promise<ResourceResponse<PartitionKeyDefinition>>;
         /**
          * Gets the partition key definition first by looking into the cache otherwise by reading the collection.
          * @hidden
          */
         readPartitionKeyDefinition(diagnosticNode: DiagnosticNodeInternal): Promise<ResourceResponse<PartitionKeyDefinition>>;
         /**
          * Gets offer on container. If none exists, returns an OfferResponse with undefined.
          */
         readOffer(options?: RequestOptions): Promise<OfferResponse>;
         getQueryPlan(query: string | SqlQuerySpec): Promise<Response_2<PartitionedQueryExecutionInfo>>;
         readPartitionKeyRanges(feedOptions?: FeedOptions): QueryIterator<PartitionKeyRange>;
         /**
          *
          * @returns all the feed ranges for which changefeed could be fetched.
          */
         getFeedRanges(): Promise<ReadonlyArray<FeedRange>>;
         /**
          * Delete all documents belong to the container for the provided partition key value
          * @param partitionKey - The partition key value of the items to be deleted
          */
         deleteAllItemsForPartitionKey(partitionKey: PartitionKey, options?: RequestOptions): Promise<ContainerResponse>;
     }

     export declare interface ContainerDefinition {
         /** The id of the container. */
         id?: string;
         /** The partition key for the container. */
         partitionKey?: PartitionKeyDefinition;
         /** The indexing policy associated with the container. */
         indexingPolicy?: IndexingPolicy;
         /** The default time to live in seconds for items in a container. */
         defaultTtl?: number;
         /** The conflict resolution policy used to resolve conflicts in a container. */
         conflictResolutionPolicy?: ConflictResolutionPolicy;
         /** Policy for additional keys that must be unique per partition key */
         uniqueKeyPolicy?: UniqueKeyPolicy;
         /** Geospatial configuration for a collection. Type is set to Geography by default */
         geospatialConfig?: {
             type: GeospatialType;
         };
         /** Change feed policy related to the container */
         changeFeedPolicy?: ChangeFeedPolicy;
         /** The computed properties of the container */
         computedProperties?: ComputedProperty[];
         /** The vector embedding policy information for storing items in a container. */
         vectorEmbeddingPolicy?: VectorEmbeddingPolicy;
         /** The full text policy information for storing items in a container. */
         fullTextPolicy?: FullTextPolicy;
     }

     export declare interface ContainerRequest extends VerboseOmit<ContainerDefinition, "partitionKey"> {
         throughput?: number;
         maxThroughput?: number;
         autoUpgradePolicy?: {
             throughputPolicy: {
                 incrementPercent: number;
             };
         };
         partitionKey?: string | PartitionKeyDefinition;
     }

     /** Response object for Container operations */
     export declare class ContainerResponse extends ResourceResponse<ContainerDefinition & Resource> {
         constructor(resource: ContainerDefinition & Resource, headers: CosmosHeaders, statusCode: number, container: Container, diagnostics: CosmosDiagnostics);
         /** A reference to the {@link Container} that the returned {@link ContainerDefinition} corresponds to. */
         readonly container: Container;
     }

     /**
      * Operations for creating new containers, and reading/querying all containers
      *
      * @see {@link Container} for reading, replacing, or deleting an existing container; use `.container(id)`.
      *
      * Note: all these operations make calls against a fixed budget.
      * You should design your system such that these calls scale sublinearly with your application.
      * For instance, do not call `containers.readAll()` before every single `item.read()` call, to ensure the container exists;
      * do this once on application start up.
      */
     export declare class Containers {
         readonly database: Database;
         private readonly clientContext;
         constructor(database: Database, clientContext: ClientContext);
         /**
          * Queries all containers.
          * @param query - Query configuration for the operation. See {@link SqlQuerySpec} for more info on how to configure a query.
          * @param options - Use to set options like response page size, continuation tokens, etc.
          * @returns {@link QueryIterator} Allows you to return specific containers in an array or iterate over them one at a time.
              * @example Read all containers to array.
              * ```typescript
              * const querySpec: SqlQuerySpec = {
              *   query: "SELECT * FROM root r WHERE r.id = @container",
              *   parameters: [
              *     {name: "@container", value: "Todo"}
              *   ]
              * };
              * const {body: containerList} = await client.database("<db id>").containers.query(querySpec).fetchAll();
              * ```
              */
          query(query: SqlQuerySpec, options?: FeedOptions): QueryIterator<any>;
          /**
           * Queries all containers.
           * @param query - Query configuration for the operation. See {@link SqlQuerySpec} for more info on how to configure a query.
           * @param options - Use to set options like response page size, continuation tokens, etc.
           * @returns {@link QueryIterator} Allows you to return specific containers in an array or iterate over them one at a time.
               * @example Read all containers to array.
               * ```typescript
               * const querySpec: SqlQuerySpec = {
               *   query: "SELECT * FROM root r WHERE r.id = @container",
               *   parameters: [
               *     {name: "@container", value: "Todo"}
               *   ]
               * };
               * const {body: containerList} = await client.database("<db id>").containers.query(querySpec).fetchAll();
               * ```
               */
           query<T>(query: SqlQuerySpec, options?: FeedOptions): QueryIterator<T>;
           /**
            * Creates a container.
            *
            * A container is a named logical container for items.
            *
            * A database may contain zero or more named containers and each container consists of
            * zero or more JSON items.
            *
            * Being schema-free, the items in a container do not need to share the same structure or fields.
            *
            *
            * Since containers are application resources, they can be authorized using either the
            * master key or resource keys.
            *
            * @param body - Represents the body of the container.
            * @param options - Use to set options like response page size, continuation tokens, etc.
            */
           create(body: ContainerRequest, options?: RequestOptions): Promise<ContainerResponse>;
           /**
            * @hidden
            */
           createInternal(diagnosticNode: DiagnosticNodeInternal, body: ContainerRequest, options?: RequestOptions): Promise<ContainerResponse>;
           /**
            * Checks if a Container exists, and, if it doesn't, creates it.
            * This will make a read operation based on the id in the `body`, then if it is not found, a create operation.
            * You should confirm that the output matches the body you passed in for non-default properties (i.e. indexing policy/etc.)
            *
            * A container is a named logical container for items.
            *
            * A database may contain zero or more named containers and each container consists of
            * zero or more JSON items.
            *
            * Being schema-free, the items in a container do not need to share the same structure or fields.
            *
            *
            * Since containers are application resources, they can be authorized using either the
            * master key or resource keys.
            *
            * @param body - Represents the body of the container.
            * @param options - Use to set options like response page size, continuation tokens, etc.
            */
           createIfNotExists(body: ContainerRequest, options?: RequestOptions): Promise<ContainerResponse>;
           /**
            * Read all containers.
            * @param options - Use to set options like response page size, continuation tokens, etc.
            * @returns {@link QueryIterator} Allows you to return all containers in an array or iterate over them one at a time.
                * @example Read all containers to array.
                * ```typescript
                * const {body: containerList} = await client.database("<db id>").containers.readAll().fetchAll();
                * ```
                */
            readAll(options?: FeedOptions): QueryIterator<ContainerDefinition & Resource>;
           }

           /**
            * Provides a client-side logical representation of the Azure Cosmos DB database account.
            * This client is used to configure and execute requests in the Azure Cosmos DB database service.
            * @example Instantiate a client and create a new database
            * ```typescript
            * const client = new CosmosClient({endpoint: "<URL HERE>", key: "<KEY HERE>"});
            * await client.databases.create({id: "<database name here>"});
            * ```
            * @example Instantiate a client with custom Connection Policy
            * ```typescript
            * const client = new CosmosClient({
            *    endpoint: "<URL HERE>",
            *    key: "<KEY HERE>",
            *    connectionPolicy: {
            *     requestTimeout: 10000,
            *    },
            * });
            * ```
            */
           export declare class CosmosClient {
               /**
                * Used for creating new databases, or querying/reading all databases.
                *
                * Use `.database(id)` to read, replace, or delete a specific, existing database by id.
                *
                * @example Create a new database
                * ```typescript
                * const {resource: databaseDefinition, database} = await client.databases.create({id: "<name here>"});
                * ```
                */
               readonly databases: Databases;
               /**
                * Used for querying & reading all offers.
                *
                * Use `.offer(id)` to read, or replace existing offers.
                */
               readonly offers: Offers;
               private clientContext;
               private endpointRefresher;
               /**
                * Creates a new {@link CosmosClient} object from a connection string. Your database connection string can be found in the Azure Portal
                */
               constructor(connectionString: string);
               /**
                * Creates a new {@link CosmosClient} object. See {@link CosmosClientOptions} for more details on what options you can use.
                * @param options - bag of options; require at least endpoint and auth to be configured
                */
               constructor(options: CosmosClientOptions);
               private initializeClientConfigDiagnostic;
               /**
                * Get information about the current {@link DatabaseAccount} (including which regions are supported, etc.)
                */
               getDatabaseAccount(options?: RequestOptions): Promise<ResourceResponse<DatabaseAccount>>;
               /**
                * @hidden
                */
               getDatabaseAccountInternal(diagnosticNode: DiagnosticNodeInternal, options?: RequestOptions): Promise<ResourceResponse<DatabaseAccount>>;
               /**
                * Gets the currently used write endpoint url. Useful for troubleshooting purposes.
                *
                * The url may contain a region suffix (e.g. "-eastus") if we're using location specific endpoints.
                */
               getWriteEndpoint(): Promise<string>;
               /**
                * Gets the currently used read endpoint. Useful for troubleshooting purposes.
                *
                * The url may contain a region suffix (e.g. "-eastus") if we're using location specific endpoints.
                */
               getReadEndpoint(): Promise<string>;
               /**
                * Gets the known write endpoints. Useful for troubleshooting purposes.
                *
                * The urls may contain a region suffix (e.g. "-eastus") if we're using location specific endpoints.
                */
               getWriteEndpoints(): Promise<readonly string[]>;
               /**
                * Gets the currently used read endpoint. Useful for troubleshooting purposes.
                *
                * The url may contain a region suffix (e.g. "-eastus") if we're using location specific endpoints.
                */
               getReadEndpoints(): Promise<readonly string[]>;
               /**
                * Used for reading, updating, or deleting a existing database by id or accessing containers belonging to that database.
                *
                * This does not make a network call. Use `.read` to get info about the database after getting the {@link Database} object.
                *
                * @param id - The id of the database.
                * @example Create a new container off of an existing database
                * ```typescript
                * const container = client.database("<database id>").containers.create("<container id>");
                * ```
                *
                * @example Delete an existing database
                * ```typescript
                * await client.database("<id here>").delete();
                * ```
                */
               database(id: string): Database;
               /**
                * Used for reading, or updating a existing offer by id.
                * @param id - The id of the offer.
                */
               offer(id: string): Offer;
               /**
                * Clears background endpoint refresher. Use client.dispose() when destroying the CosmosClient within another process.
                */
               dispose(): void;
               private backgroundRefreshEndpointList;
           }

           export declare interface CosmosClientOptions {
               /** The service endpoint to use to create the client. */
               endpoint: string;
               /** The account master or readonly key */
               key?: string;
               /** An object that contains resources tokens.
                * Keys for the object are resource Ids and values are the resource tokens.
                */
               resourceTokens?: {
                   [resourcePath: string]: string;
               };
               /** A user supplied function for resolving header authorization tokens.
                * Allows users to generating their own auth tokens, potentially using a separate service
                */
               tokenProvider?: TokenProvider;
               /** AAD token from `@azure/identity`
                * Obtain a credential object by creating an `@azure/identity` credential object
                * We will then use your credential object and a scope URL (your cosmos db endpoint)
                * to authenticate requests to Cosmos
                */
               aadCredentials?: TokenCredential;
               /** An array of {@link Permission} objects. */
               permissionFeed?: PermissionDefinition[];
               /** An instance of {@link ConnectionPolicy} class.
                * This parameter is optional and the default connectionPolicy will be used if omitted.
                */
               connectionPolicy?: ConnectionPolicy;
               /** An optional parameter that represents the consistency level.
                * It can take any value from {@link ConsistencyLevel}.
                */
               consistencyLevel?: keyof typeof ConsistencyLevel;
               defaultHeaders?: CosmosHeaders_2;
               /** An optional custom http(s) Agent to be used in NodeJS enironments
                * Use an agent such as https://github.com/TooTallNate/node-proxy-agent if you need to connect to Cosmos via a proxy
                */
               agent?: Agent;
               /** An optional custom `HttpClient` shape to customize how requests are made by the HTTP pipeline.
                * See `@azure/core-rest-pipeline` for details on how to implement this interface. */
               httpClient?: HttpClient;
               /** A custom string to append to the default SDK user agent. */
               userAgentSuffix?: string;
               diagnosticLevel?: CosmosDbDiagnosticLevel;
           }

           /**
            * @hidden
            */
           declare enum CosmosContainerChildResourceKind {
               Item = "ITEM",
               StoredProcedure = "STORED_PROCEDURE",
               UserDefinedFunction = "USER_DEFINED_FUNCTION",
               Trigger = "TRIGGER"
           }

           /**
            * Cosmos DB Diagnostic Level
            */
           export declare enum CosmosDbDiagnosticLevel {
               info = "info",
               debug = "debug",
               debugUnsafe = "debug-unsafe"
           }

           /**
            *  * This is a Cosmos Diagnostic type that holds collected diagnostic information during a client operations. ie. Item.read(), Container.create().
            * It has three members -
            * 1. `clientSideRequestStatistics` member contains aggregate diagnostic information, including -
            *   - metadata lookups. Here all the server requests, apart from the final intended resource are considered as metadata calls.
            *    i.e. for item.read(id), if the client makes server call to discover endpoints it would be considered as metadata call.
            *   - retries
            *   - endpoints contacted.
            *   - request, response payload stats.
            *   - gatewayStatistics - Information corresponding to main operation. For example during Item.read(), the client might perform many operations
            *    i.e. metadata lookup etc, but gatewayStatistics represents the diagnostics information for actual read operation.
            *
            * 2. diagnosticNode - Is a tree like structure which captures detailed diagnostic information. By default it is disabled, and is intended to be
            * used only for debugging on non production environments. The kind of details captured in diagnosticNode is controlled by `CosmosDbDiagnosticLevel`.
            * - CosmosDbDiagnosticLevel.info - Is default value. In this level only clientSideRequestStatistics are captured. Is is meant for production environments.
            * - CosmosDbDiagnosticLevel.debug - Captures diagnosticNode and clientConfig. No request and response payloads are captured. Is not meant to be used
            * in production environment.
            * - CosmosDbDiagnosticLevel.debug-unsafe - In addition to data captured in CosmosDbDiagnosticLevel.debug, also captures request and response payloads.
            * Is not meant to be used in production environment.
            * 3. clientConfig - Captures information related to how client was configured during initialization.
            */
           export declare class CosmosDiagnostics {
               readonly clientSideRequestStatistics: ClientSideRequestStatistics;
               readonly diagnosticNode: DiagnosticNode;
               readonly clientConfig?: ClientConfigDiagnostic;
           }

           export declare interface CosmosHeaders {
               [key: string]: any;
           }

           declare interface CosmosHeaders_2 {
               [key: string]: string | boolean | number;
           }

           /**
            * @hidden
            */
           declare enum CosmosKeyType {
               PrimaryMaster = "PRIMARY_MASTER",
               SecondaryMaster = "SECONDARY_MASTER",
               PrimaryReadOnly = "PRIMARY_READONLY",
               SecondaryReadOnly = "SECONDARY_READONLY"
           }

           /**
            * Experimental internal only
            * Generates the payload representing the permission configuration for the sas token.
            */
           export declare function createAuthorizationSasToken(masterKey: string, sasTokenProperties: SasTokenProperties): Promise<string>;

           export declare type CreateOperation = OperationWithItem & {
               operationType: typeof BulkOperationType.Create;
           };

           export declare interface CreateOperationInput {
               partitionKey?: PartitionKey;
               ifMatch?: string;
               ifNoneMatch?: string;
               operationType: typeof BulkOperationType.Create;
               resourceBody: JSONObject;
           }

           /**
            * Operations for reading or deleting an existing database.
            *
            * @see {@link Databases} for creating new databases, and reading/querying all databases; use `client.databases`.
            *
            * Note: all these operations make calls against a fixed budget.
            * You should design your system such that these calls scale sublinearly with your application.
            * For instance, do not call `database.read()` before every single `item.read()` call, to ensure the database exists;
            * do this once on application start up.
            */
           export declare class Database {
               readonly client: CosmosClient;
               readonly id: string;
               private clientContext;
               /**
                * Used for creating new containers, or querying/reading all containers.
                *
                * Use `.database(id)` to read, replace, or delete a specific, existing {@link Database} by id.
                *
                * @example Create a new container
                * ```typescript
                * const {body: containerDefinition, container} = await client.database("<db id>").containers.create({id: "<container id>"});
                * ```
                */
               readonly containers: Containers;
               /**
                * Used for creating new users, or querying/reading all users.
                *
                * Use `.user(id)` to read, replace, or delete a specific, existing {@link User} by id.
                */
               readonly users: Users;
               /**
                * Returns a reference URL to the resource. Used for linking in Permissions.
                */
               get url(): string;
               /** Returns a new {@link Database} instance.
                *
                * Note: the intention is to get this object from {@link CosmosClient} via `client.database(id)`, not to instantiate it yourself.
                */
               constructor(client: CosmosClient, id: string, clientContext: ClientContext);
               /**
                * Used to read, replace, or delete a specific, existing {@link Database} by id.
                *
                * Use `.containers` creating new containers, or querying/reading all containers.
                *
                * @example Delete a container
                * ```typescript
                * await client.database("<db id>").container("<container id>").delete();
                * ```
                */
               container(id: string): Container;
               /**
                * Used to read, replace, or delete a specific, existing {@link User} by id.
                *
                * Use `.users` for creating new users, or querying/reading all users.
                */
               user(id: string): User;
               /** Read the definition of the given Database. */
               read(options?: RequestOptions): Promise<DatabaseResponse>;
               /**
                * @hidden
                */
               readInternal(diagnosticNode: DiagnosticNodeInternal, options?: RequestOptions): Promise<DatabaseResponse>;
               /** Delete the given Database. */
               delete(options?: RequestOptions): Promise<DatabaseResponse>;
               /**
                * Gets offer on database. If none exists, returns an OfferResponse with undefined.
                */
               readOffer(options?: RequestOptions): Promise<OfferResponse>;
           }

           /**
            * Represents a DatabaseAccount in the Azure Cosmos DB database service.
            */
           export declare class DatabaseAccount {
               /** The list of writable locations for a geo-replicated database account. */
               readonly writableLocations: Location[];
               /** The list of readable locations for a geo-replicated database account. */
               readonly readableLocations: Location[];
               /**
                * The self-link for Databases in the databaseAccount.
                * @deprecated Use `databasesLink`
                */
               get DatabasesLink(): string;
               /** The self-link for Databases in the databaseAccount. */
               readonly databasesLink: string;
               /**
                * The self-link for Media in the databaseAccount.
                * @deprecated Use `mediaLink`
                */
               get MediaLink(): string;
               /** The self-link for Media in the databaseAccount. */
               readonly mediaLink: string;
               /**
                * Attachment content (media) storage quota in MBs ( Retrieved from gateway ).
                * @deprecated use `maxMediaStorageUsageInMB`
                */
               get MaxMediaStorageUsageInMB(): number;
               /** Attachment content (media) storage quota in MBs ( Retrieved from gateway ). */
               readonly maxMediaStorageUsageInMB: number;
               /**
                * Current attachment content (media) usage in MBs (Retrieved from gateway )
                *
                * Value is returned from cached information updated periodically and is not guaranteed
                * to be real time.
                *
                * @deprecated use `currentMediaStorageUsageInMB`
                */
               get CurrentMediaStorageUsageInMB(): number;
               /**
                * Current attachment content (media) usage in MBs (Retrieved from gateway )
                *
                * Value is returned from cached information updated periodically and is not guaranteed
                * to be real time.
                */
               readonly currentMediaStorageUsageInMB: number;
               /**
                * Gets the UserConsistencyPolicy settings.
                * @deprecated use `consistencyPolicy`
                */
               get ConsistencyPolicy(): ConsistencyLevel;
               /** Gets the UserConsistencyPolicy settings. */
               readonly consistencyPolicy: ConsistencyLevel;
               readonly enableMultipleWritableLocations: boolean;
               constructor(body: {
                   [key: string]: any;
               }, headers: CosmosHeaders);
           }

           export declare interface DatabaseDefinition {
               /** The id of the database. */
               id?: string;
           }

           export declare interface DatabaseRequest extends DatabaseDefinition {
               /** Throughput for this database. */
               throughput?: number;
               maxThroughput?: number;
               autoUpgradePolicy?: {
                   throughputPolicy: {
                       incrementPercent: number;
                   };
               };
           }

           /** Response object for Database operations */
           export declare class DatabaseResponse extends ResourceResponse<DatabaseDefinition & Resource> {
               constructor(resource: DatabaseDefinition & Resource, headers: CosmosHeaders, statusCode: number, database: Database, diagnostics: CosmosDiagnostics);
               /** A reference to the {@link Database} that the returned {@link DatabaseDefinition} corresponds to. */
               readonly database: Database;
           }

           /**
            * Operations for creating new databases, and reading/querying all databases
            *
            * @see {@link Database} for reading or deleting an existing database; use `client.database(id)`.
            *
            * Note: all these operations make calls against a fixed budget.
            * You should design your system such that these calls scale sublinearly with your application.
            * For instance, do not call `databases.readAll()` before every single `item.read()` call, to ensure the database exists;
            * do this once on application start up.
            */
           export declare class Databases {
               readonly client: CosmosClient;
               private readonly clientContext;
               /**
                * @hidden
                * @param client - The parent {@link CosmosClient} for the Database.
                */
               constructor(client: CosmosClient, clientContext: ClientContext);
               /**
                * Queries all databases.
                * @param query - Query configuration for the operation. See {@link SqlQuerySpec} for more info on how to configure a query.
                * @param options - Use to set options like response page size, continuation tokens, etc.
                * @returns {@link QueryIterator} Allows you to return all databases in an array or iterate over them one at a time.
                    * @example Read all databases to array.
                    * ```typescript
                    * const querySpec: SqlQuerySpec = {
                    *   query: "SELECT * FROM root r WHERE r.id = @db",
                    *   parameters: [
                    *     {name: "@db", value: "Todo"}
                    *   ]
                    * };
                    * const {body: databaseList} = await client.databases.query(querySpec).fetchAll();
                    * ```
                    */
                query(query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<any>;
                /**
                 * Queries all databases.
                 * @param query - Query configuration for the operation. See {@link SqlQuerySpec} for more info on how to configure a query.
                 * @param options - Use to set options like response page size, continuation tokens, etc.
                 * @returns {@link QueryIterator} Allows you to return all databases in an array or iterate over them one at a time.
                     * @example Read all databases to array.
                     * ```typescript
                     * const querySpec: SqlQuerySpec = {
                     *   query: "SELECT * FROM root r WHERE r.id = @db",
                     *   parameters: [
                     *     {name: "@db", value: "Todo"}
                     *   ]
                     * };
                     * const {body: databaseList} = await client.databases.query(querySpec).fetchAll();
                     * ```
                     */
                 query<T>(query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<T>;
                 /**
                  * Send a request for creating a database.
                  *
                  * A database manages users, permissions and a set of containers.
                  * Each Azure Cosmos DB Database Account is able to support multiple independent named databases,
                  * with the database being the logical container for data.
                  *
                  * Each Database consists of one or more containers, each of which in turn contain one or more
                  * documents. Since databases are an administrative resource, the Service Master Key will be
                  * required in order to access and successfully complete any action using the User APIs.
                  *
                  * @param body - The {@link DatabaseDefinition} that represents the {@link Database} to be created.
                  * @param options - Use to set options like response page size, continuation tokens, etc.
                  */
                 create(body: DatabaseRequest, options?: RequestOptions): Promise<DatabaseResponse>;
                 /**
                  * @hidden
                  */
                 createInternal(diagnosticNode: DiagnosticNodeInternal, body: DatabaseRequest, options?: RequestOptions): Promise<DatabaseResponse>;
                 /**
                  * Check if a database exists, and if it doesn't, create it.
                  * This will make a read operation based on the id in the `body`, then if it is not found, a create operation.
                  *
                  * A database manages users, permissions and a set of containers.
                  * Each Azure Cosmos DB Database Account is able to support multiple independent named databases,
                  * with the database being the logical container for data.
                  *
                  * Each Database consists of one or more containers, each of which in turn contain one or more
                  * documents. Since databases are an an administrative resource, the Service Master Key will be
                  * required in order to access and successfully complete any action using the User APIs.
                  *
                  * @param body - The {@link DatabaseDefinition} that represents the {@link Database} to be created.
                  * @param options - Additional options for the request
                  */
                 createIfNotExists(body: DatabaseRequest, options?: RequestOptions): Promise<DatabaseResponse>;
                 /**
                  * Reads all databases.
                  * @param options - Use to set options like response page size, continuation tokens, etc.
                  * @returns {@link QueryIterator} Allows you to return all databases in an array or iterate over them one at a time.
                      * @example Read all databases to array.
                      * ```typescript
                      * const {body: databaseList} = await client.databases.readAll().fetchAll();
                      * ```
                      */
                  readAll(options?: FeedOptions): QueryIterator<DatabaseDefinition & Resource>;
                 }

                 /** Defines a target data type of an index path specification in the Azure Cosmos DB service. */
                 export declare enum DataType {
                     /** Represents a numeric data type. */
                     Number = "Number",
                     /** Represents a string data type. */
                     String = "String",
                     /** Represents a point data type. */
                     Point = "Point",
                     /** Represents a line string data type. */
                     LineString = "LineString",
                     /** Represents a polygon data type. */
                     Polygon = "Polygon",
                     /** Represents a multi-polygon data type. */
                     MultiPolygon = "MultiPolygon"
                 }

                 export declare const DEFAULT_PARTITION_KEY_PATH: "/_partitionKey";

                 export declare type DeleteOperation = OperationBase & {
                     operationType: typeof BulkOperationType.Delete;
                     id: string;
                 };

                 export declare interface DeleteOperationInput {
                     partitionKey?: PartitionKey;
                     operationType: typeof BulkOperationType.Delete;
                     id: string;
                 }

                 /**
                  * @hidden
                  */
                 export declare type DiagnosticDataValue = {
                     selectedLocation: string;
                     activityId: string;
                     requestAttempNumber: number;
                     requestPayloadLengthInBytes: number;
                     responsePayloadLengthInBytes: number;
                     responseStatus: number;
                     readFromCache: boolean;
                     operationType: OperationType;
                     metadatOperationType: MetadataLookUpType;
                     resourceType: ResourceType;
                     failedAttempty: boolean;
                     successfulRetryPolicy: string;
                     partitionKeyRangeId: string;
                     stateful: boolean;
                     queryRecordsRead: number;
                     queryMethodIdentifier: string;
                     log: string[];
                     failure: boolean;
                     startTimeUTCInMs: number;
                     durationInMs: number;
                     requestData: Partial<{
                         requestPayloadLengthInBytes: number;
                         responsePayloadLengthInBytes: number;
                         operationType: OperationType;
                         resourceType: ResourceType;
                         headers: CosmosHeaders_2;
                         requestBody: any;
                         responseBody: any;
                         url: string;
                     }>;
                 };

                 /**
                  * Represents a tree like structure, for capturing diagnostic information.
                  */
                 export declare interface DiagnosticNode {
                     id: string;
                     nodeType: string;
                     children: DiagnosticNode[];
                     data: {
                         [key: string]: any;
                     };
                     startTimeUTCInMs: number;
                     durationInMs: number;
                 }

                 /**
                  * @hidden
                  * This is Internal Representation for DiagnosticNode. It contains useful helper functions to collect
                  * diagnostic information throughout the lifetime of Diagnostic session.
                  * The functions toDiagnosticNode() & toDiagnostic() are given to convert it to public facing counterpart.
                  */
                 export declare class DiagnosticNodeInternal implements DiagnosticNode {
                     id: string;
                     nodeType: DiagnosticNodeType;
                     parent: DiagnosticNodeInternal;
                     children: DiagnosticNodeInternal[];
                     data: Partial<DiagnosticDataValue>;
                     startTimeUTCInMs: number;
                     durationInMs: number;
                     diagnosticLevel: CosmosDbDiagnosticLevel;
                     private diagnosticCtx;
                 }

                 /**
                  * @hidden
                  */
                 export declare enum DiagnosticNodeType {
                     CLIENT_REQUEST_NODE = "CLIENT_REQUEST_NODE",// Top most node representing client operations.
                     METADATA_REQUEST_NODE = "METADATA_REQUEST_NODE",// Node representing a metadata request.
                     HTTP_REQUEST = "HTTP_REQUEST",// Node representing REST call to backend services.
                     BATCH_REQUEST = "BATCH_REQUEST",// Node representing batch request.
                     PARALLEL_QUERY_NODE = "PARALLEL_QUERY_NODE",// Node representing parallel query execution.
                     DEFAULT_QUERY_NODE = "DEFAULT_QUERY_NODE",// Node representing default query execution.
                     QUERY_REPAIR_NODE = "QUERY_REPAIR_NODE",// Node representing query repair.
                     BACKGROUND_REFRESH_THREAD = "BACKGROUND_REFRESH_THREAD",// Node representing background refresh.
                     REQUEST_ATTEMPTS = "REQUEST_ATTEMPTS"
                 }

                 export declare interface ErrorBody {
                     code: string;
                     message: string;
                     /**
                      * @hidden
                      */
                     additionalErrorInfo?: PartitionedQueryExecutionInfo;
                 }

                 export declare class ErrorResponse extends Error {
                     code?: number | string;
                     substatus?: number;
                     body?: ErrorBody;
                     headers?: CosmosHeaders;
                     activityId?: string;
                     retryAfterInMs?: number;
                     retryAfterInMilliseconds?: number;
                     [key: string]: any;
                     diagnostics?: CosmosDiagnostics;
                 }

                 export declare type ExistingKeyOperation = {
                     op: keyof typeof PatchOperationType;
                     value: any;
                     path: string;
                 };

                 /**
                  * This type captures diagnostic information regarding a failed request to server api.
                  */
                 export declare interface FailedRequestAttemptDiagnostic {
                     attemptNumber: number;
                     activityId: string;
                     startTimeUTCInMs: number;
                     durationInMs: number;
                     operationType?: OperationType;
                     resourceType?: ResourceType;
                     statusCode: number;
                     substatusCode?: number;
                     requestPayloadLengthInBytes: number;
                     responsePayloadLengthInBytes: number;
                 }

                 /**
                  * The feed options and query methods.
                  */
                 export declare interface FeedOptions extends SharedOptions {
                     /** Opaque token for continuing the enumeration. Default: undefined
                      * @deprecated Use continuationToken instead.
                      */
                     continuation?: string;
                     /** Opaque token for continuing the enumeration. Default: undefined */
                     continuationToken?: string;
                     /**
                      * Limits the size of the continuation token in the response. Default: undefined
                      *
                      * Continuation Tokens contain optional data that can be removed from the serialization before writing it out to a header.
                      * By default we are capping this to 1kb to avoid long headers (Node.js has a global header size limit).
                      * A user may set this field to allow for longer headers, which can help the backend optimize query execution."
                      */
                     continuationTokenLimitInKB?: number;
                     /**
                      * Allow scan on the queries which couldn't be served as indexing was opted out on the requested paths. Default: false
                      *
                      * In general, it is best to avoid using this setting. Scans are relatively expensive and take a long time to serve.
                      */
                     enableScanInQuery?: boolean;
                     /**
                      * The maximum number of concurrent operations that run client side during parallel query execution in the
                      * Azure Cosmos DB database service. Negative values make the system automatically decides the number of
                      * concurrent operations to run. Default: 0 (no parallelism)
                      */
                     maxDegreeOfParallelism?: number;
                     /**
                      * Max number of items to be returned in the enumeration operation. Default: undefined (server will defined payload)
                      *
                      * Expirimenting with this value can usually result in the biggest performance changes to the query.
                      *
                      * The smaller the item count, the faster the first result will be delivered (for non-aggregates). For larger amounts,
                      * it will take longer to serve the request, but you'll usually get better throughput for large queries (i.e. if you need 1000 items
                      * before you can do any other actions, set `maxItemCount` to 1000. If you can start doing work after the first 100, set `maxItemCount` to 100.)
                      */
                     maxItemCount?: number;
                     /**
                      * Note: consider using changeFeed instead.
                      *
                      * Indicates a change feed request. Must be set to "Incremental feed", or omitted otherwise. Default: false
                      */
                     useIncrementalFeed?: boolean;
                     /** Conditions Associated with the request. */
                     accessCondition?: {
                         /** Conditional HTTP method header type (IfMatch or IfNoneMatch). */
                         type: string;
                         /** Conditional HTTP method header value (the _etag field from the last version you read). */
                         condition: string;
                     };
                     /**
                      * Enable returning query metrics in response headers. Default: false
                      *
                      * Used for debugging slow or expensive queries. Also increases response size and if you're using a low max header size in Node.js,
                      * you can run into issues faster.
                      */
                     populateQueryMetrics?: boolean;
                     /**
                      * Enable buffering additional items during queries. Default: false
                      *
                      * This will buffer an additional page at a time (multiplied by maxDegreeOfParallelism) from the server in the background.
                      * This improves latency by fetching pages before they are needed by the client. If you're draining all of the results from the
                      * server, like `.fetchAll`, you should usually enable this. If you're only fetching one page at a time via continuation token,
                      * you should avoid this. If you're draining more than one page, but not the entire result set, it may help improve latency, but
                      * it will increase the total amount of RU/s use to serve the entire query (as some pages will be fetched more than once).
                      */
                     bufferItems?: boolean;
                     /**
                      * This setting forces the query to use a query plan. Default: false
                      *
                      * Note: this will disable continuation token support, even for single partition queries.
                      *
                      * For queries like aggregates and most cross partition queries, this happens anyway.
                      * However, since the library doesn't know what type of query it is until we get back the first response,
                      * some optimization can't happen until later.
                      *
                      * If this setting is enabled, it will force query plan for the query, which will save some network requests
                      * and ensure parallelism can happen. Useful for when you know you're doing cross-partition or aggregate queries.
                      */
                     forceQueryPlan?: boolean;
                     /** Limits the query to a specific partition key. Default: undefined
                      *
                      *  Scoping a query to a single partition can be accomplished two ways:
                      *
                      * `container.items.query('SELECT * from c', { partitionKey: "foo" }).toArray()`
                      * `container.items.query('SELECT * from c WHERE c.yourPartitionKey = "foo"').toArray()`
                      *
                      * The former is useful when the query body is out of your control
                      * but you still want to restrict it to a single partition. Example: an end user specified query.
                      */
                     partitionKey?: PartitionKey;
                     /**
                      * Enable returning index metrics in response headers. Default: false
                      */
                     populateIndexMetrics?: boolean;
                     /**
                      * Specifies a custom maximum buffer size for storing final results for nonStreamingOrderBy queries.
                      * This value is ignored if the query includes top/offset+limit clauses.
                      */
                     vectorSearchBufferSize?: number;
                     /**
                      * Disable the nonStreamingOrderBy query feature in supported query features.
                      * Default: false. Set to true to avoid error from an old gateway that doesn't support this feature.
                      */
                     disableNonStreamingOrderByQuery?: boolean;
                     /**
                      * Valid only for non streaming order by query.
                      * Default: false; When set to true, it allows queries to bypass the default behavior that blocks nonStreaming queries without top or limit clauses.
                      */
                     allowUnboundedNonStreamingQueries?: boolean;
                 }

                 /**
                  * Specifies a feed range for the changefeed.
                  */
                 export declare abstract class FeedRange {
                     /**
                      * Min value for the feed range.
                      */
                     readonly minInclusive: string;
                     /**
                      * Max value for the feed range.
                      */
                     readonly maxExclusive: string;
                 }

                 export declare class FeedResponse<TResource> {
                     readonly resources: TResource[];
                     private readonly headers;
                     readonly hasMoreResults: boolean;
                     readonly diagnostics: CosmosDiagnostics;
                     constructor(resources: TResource[], headers: CosmosHeaders, hasMoreResults: boolean, diagnostics: CosmosDiagnostics);
                     get continuation(): string;
                     get continuationToken(): string;
                     get queryMetrics(): string;
                     get requestCharge(): number;
                     get activityId(): string;
                     get correlatedActivityId(): string;
                     get indexMetrics(): string;
                 }

                 /** @hidden */
                 declare type FetchFunctionCallback = (diagnosticNode: DiagnosticNodeInternal, options: FeedOptions, correlatedActivityId: string) => Promise<Response_2<any>>;

                 /**
                  * Represents a full text index in the indexing policy.
                  */
                 export declare interface FullTextIndex {
                     /** The path in the JSON document to index. */
                     path: string;
                 }

                 /**
                  * Represents a full text path to be indexed in the Azure Cosmos DB service.
                  */
                 export declare interface FullTextPath {
                     /**
                      * The path to be indexed for full text search.
                      */
                     path: string;
                     /**
                      * The language for the full text path.
                      */
                     language: string;
                 }

                 /**
                  * Represents a full text policy for a collection in the Azure Cosmos DB service.
                  */
                 export declare interface FullTextPolicy {
                     /**
                      * The default language for the full text .
                      */
                     defaultLanguage: string;
                     /**
                      * The paths to be indexed for full text search.
                      */
                     fullTextPaths: FullTextPath[];
                 }

                 export declare type GatewayStatistics = {
                     /**
                      * This is the activityId for request, made to server for fetching the requested resource. (As opposed to other potential meta data requests)
                      */
                     activityId?: string;
                     correlatedActivityId?: string;
                     startTimeUTCInMs: number;
                     durationInMs: number;
                     operationType?: OperationType;
                     resourceType?: ResourceType;
                     statusCode?: number;
                     subStatusCode?: number;
                     requestCharge?: number;
                     requestPayloadLengthInBytes: number;
                     responsePayloadLengthInBytes: number;
                 };

                 export declare enum GeospatialType {
                     /** Represents data in round-earth coordinate system. */
                     Geography = "Geography",
                     /** Represents data in Eucledian(flat) coordinate system. */
                     Geometry = "Geometry"
                 }

                 /**
                  * @hidden
                  * This internal class implements the logic for endpoint management for geo-replicated database accounts.
                  */
                 export declare class GlobalEndpointManager {
                     private readDatabaseAccount;
                     /**
                      * The endpoint used to create the client instance.
                      */
                     private defaultEndpoint;
                     /**
                      * Flag to enable/disable automatic redirecting of requests based on read/write operations.
                      */
                     enableEndpointDiscovery: boolean;
                     private isRefreshing;
                     private options;
                     /**
                      * List of azure regions to be used as preferred locations for read requests.
                      */
                     private preferredLocations;
                     private writeableLocations;
                     private readableLocations;
                     private unavailableReadableLocations;
                     private unavailableWriteableLocations;
                     preferredLocationsCount: number;
                     /**
                      * Gets the current read endpoint from the endpoint cache.
                      */
                     getReadEndpoint(diagnosticNode: DiagnosticNodeInternal): Promise<string>;
                     /**
                      * Gets the current write endpoint from the endpoint cache.
                      */
                     getWriteEndpoint(diagnosticNode: DiagnosticNodeInternal): Promise<string>;
                     getReadEndpoints(): Promise<ReadonlyArray<string>>;
                     getWriteEndpoints(): Promise<ReadonlyArray<string>>;
                     markCurrentLocationUnavailableForRead(diagnosticNode: DiagnosticNodeInternal, endpoint: string): Promise<void>;
                     markCurrentLocationUnavailableForWrite(diagnosticNode: DiagnosticNodeInternal, endpoint: string): Promise<void>;
                     canUseMultipleWriteLocations(resourceType?: ResourceType, operationType?: OperationType): boolean;
                     resolveServiceEndpoint(diagnosticNode: DiagnosticNodeInternal, resourceType: ResourceType, operationType: OperationType, startServiceEndpointIndex?: number): Promise<string>;
                     /**
                      * Refreshes the endpoint list by clearning stale unavailability and then
                      *  retrieving the writable and readable locations from the geo-replicated database account
                      *  and then updating the locations cache.
                      *  We skip the refreshing if enableEndpointDiscovery is set to False
                      */
                     refreshEndpointList(diagnosticNode: DiagnosticNodeInternal): Promise<void>;
                     private refreshEndpoints;
                     private refreshStaleUnavailableLocations;
                     /**
                      * update the locationUnavailability to undefined if the location is available again
                      * @param now - current time
                      * @param unavailableLocations - list of unavailable locations
                      * @param allLocations - list of all locations
                      */
                     private updateLocation;
                     private cleanUnavailableLocationList;
                     /**
                      * Gets the database account first by using the default endpoint, and if that doesn't returns
                      * use the endpoints for the preferred locations in the order they are specified to get
                      * the database account.
                      */
                     private getDatabaseAccountFromAnyEndpoint;
                     /**
                      * Gets the locational endpoint using the location name passed to it using the default endpoint.
                      *
                      * @param defaultEndpoint - The default endpoint to use for the endpoint.
                      * @param locationName    - The location name for the azure region like "East US".
                      */
                     private static getLocationalEndpoint;
                 }

                 export declare interface GroupByAliasToAggregateType {
                     [key: string]: AggregateType;
                 }

                 export declare type GroupByExpressions = string[];

                 /**
                  * @hidden
                  */
                 export declare enum HTTPMethod {
                     get = "GET",
                     patch = "PATCH",
                     post = "POST",
                     put = "PUT",
                     delete = "DELETE"
                 }

                 /**
                  * @hidden
                  * Represents the hybrid search query information
                  */
                 export declare interface HybridSearchQueryInfo {
                     /**
                      * The query to be used for fetching global statistics
                      */
                     globalStatisticsQuery: string;
                     /**
                      * Query information for the subsequent queries
                      */
                     componentQueryInfos: QueryInfo[];
                     /**
                      * The number of results in the final result set
                      */
                     take: number;
                     /**
                      * The number of results to skip in the final result set
                      */
                     skip: number;
                     /**
                      * Whether the query requires global statistics
                      */
                     requiresGlobalStatistics: boolean;
                 }

                 export declare interface Index {
                     kind: keyof typeof IndexKind;
                     dataType: keyof typeof DataType;
                     precision?: number;
                 }

                 export declare interface IndexedPath {
                     path: string;
                     indexes?: Index[];
                 }

                 /**
                  * Specifies the supported indexing modes.
                  */
                 export declare enum IndexingMode {
                     /**
                      * Index is updated synchronously with a create or update operation.
                      *
                      * With consistent indexing, query behavior is the same as the default consistency level for the container.
                      * The index is always kept up to date with the data.
                      */
                     consistent = "consistent",
                     /**
                      * Index is updated asynchronously with respect to a create or update operation.
                      *
                      * With lazy indexing, queries are eventually consistent. The index is updated when the container is idle.
                      */
                     lazy = "lazy",
                     /** No Index is provided. */
                     none = "none"
                 }

                 export declare interface IndexingPolicy {
                     /** The indexing mode (consistent or lazy) {@link IndexingMode}. */
                     indexingMode?: keyof typeof IndexingMode;
                     automatic?: boolean;
                     /** An array of {@link IncludedPath} represents the paths to be included for indexing. */
                     includedPaths?: IndexedPath[];
                     /** An array of {@link IncludedPath} represents the paths to be excluded for indexing. */
                     excludedPaths?: IndexedPath[];
                     spatialIndexes?: SpatialIndex[];
                     /** An array of {@link VectorIndex} represents the vector index paths to be included for indexing. */
                     vectorIndexes?: VectorIndex[];
                     /** An array of {@link CompositeIndexes} representing composite indexes to be included. */
                     compositeIndexes?: CompositePath[][];
                     /** An array of {@link FullTextIndex} representing full text indexes to be included. */
                     fullTextIndexes?: FullTextIndex[];
                 }

                 /**
                  * Specifies the supported Index types.
                  */
                 export declare enum IndexKind {
                     /**
                      * This is supplied for a path which requires sorting.
                      */
                     Range = "Range",
                     /**
                      * This is supplied for a path which requires geospatial indexing.
                      */
                     Spatial = "Spatial"
                 }

                 /**
                  * Used to perform operations on a specific item.
                  *
                  * @see {@link Items} for operations on all items; see `container.items`.
                  */
                 export declare class Item {
                     readonly container: Container;
                     readonly id: string;
                     private readonly clientContext;
                     private partitionKey;
                     /**
                      * Returns a reference URL to the resource. Used for linking in Permissions.
                      */
                     get url(): string;
                     /**
                      * @hidden
                      * @param container - The parent {@link Container}.
                      * @param id - The id of the given {@link Item}.
                      * @param partitionKey - The primary key of the given {@link Item} (only for partitioned containers).
                      */
                     constructor(container: Container, id: string, clientContext: ClientContext, partitionKey?: PartitionKey);
                     /**
                      * Read the item's definition.
                      *
                      * Any provided type, T, is not necessarily enforced by the SDK.
                      * You may get more or less properties and it's up to your logic to enforce it.
                      * If the type, T, is a class, it won't pass `typeof` comparisons, because it won't have a match prototype.
                      * It's recommended to only use interfaces.
                      *
                      * There is no set schema for JSON items. They may contain any number of custom properties.
                      *
                      * @param options - Additional options for the request
                      *
                      * @example Using custom type for response
                      * ```typescript
                      * interface TodoItem {
                      *   title: string;
                      *   done: bool;
                      *   id: string;
                      * }
                      *
                      * let item: TodoItem;
                      * ({body: item} = await item.read<TodoItem>());
                      * ```
                      */
                     read<T extends ItemDefinition = any>(options?: RequestOptions): Promise<ItemResponse<T>>;
                     /**
                      * Replace the item's definition.
                      *
                      * There is no set schema for JSON items. They may contain any number of custom properties.
                      *
                      * @param body - The definition to replace the existing {@link Item}'s definition with.
                      * @param options - Additional options for the request
                      */
                     replace(body: ItemDefinition, options?: RequestOptions): Promise<ItemResponse<ItemDefinition>>;
                     /**
                      * Replace the item's definition.
                      *
                      * Any provided type, T, is not necessarily enforced by the SDK.
                      * You may get more or less properties and it's up to your logic to enforce it.
                      *
                      * There is no set schema for JSON items. They may contain any number of custom properties.
                      *
                      * @param body - The definition to replace the existing {@link Item}'s definition with.
                      * @param options - Additional options for the request
                      */
                     replace<T extends ItemDefinition>(body: T, options?: RequestOptions): Promise<ItemResponse<T>>;
                     /**
                      * Delete the item.
                      *
                      * Any provided type, T, is not necessarily enforced by the SDK.
                      * You may get more or less properties and it's up to your logic to enforce it.
                      *
                      * @param options - Additional options for the request
                      */
                     delete<T extends ItemDefinition = any>(options?: RequestOptions): Promise<ItemResponse<T>>;
                     /**
                      * Perform a JSONPatch on the item.
                      *
                      * Any provided type, T, is not necessarily enforced by the SDK.
                      * You may get more or less properties and it's up to your logic to enforce it.
                      *
                      * @param options - Additional options for the request
                      */
                     patch<T extends ItemDefinition = any>(body: PatchRequestBody, options?: RequestOptions): Promise<ItemResponse<T>>;
                 }

                 /**
                  * Items in Cosmos DB are simply JSON objects.
                  * Most of the Item operations allow for your to provide your own type
                  * that extends the very simple ItemDefinition.
                  *
                  * You cannot use any reserved keys. You can see the reserved key list
                  * in {@link ItemBody}
                  */
                 export declare interface ItemDefinition {
                     /** The id of the item. User settable property. Uniquely identifies the item along with the partition key */
                     id?: string;
                     /** Time to live in seconds for collections with TTL enabled */
                     ttl?: number;
                     [key: string]: any;
                 }

                 export declare class ItemResponse<T extends ItemDefinition> extends ResourceResponse<T & Resource> {
                     constructor(resource: T & Resource, headers: CosmosHeaders, statusCode: number, subsstatusCode: number, item: Item, diagnostics: CosmosDiagnostics);
                     /** Reference to the {@link Item} the response corresponds to. */
                     readonly item: Item;
                 }

                 /**
                  * Operations for creating new items, and reading/querying all items
                  *
                  * @see {@link Item} for reading, replacing, or deleting an existing container; use `.item(id)`.
                  */
                 export declare class Items {
                     readonly container: Container;
                     private readonly clientContext;
                     private partitionKeyRangeCache;
                     /**
                      * Create an instance of {@link Items} linked to the parent {@link Container}.
                      * @param container - The parent container.
                      * @hidden
                      */
                     constructor(container: Container, clientContext: ClientContext);
                     /**
                      * Queries all items.
                      * @param query - Query configuration for the operation. See {@link SqlQuerySpec} for more info on how to configure a query.
                      * @param options - Used for modifying the request (for instance, specifying the partition key).
                      * @example Read all items to array.
                      * ```typescript
                      * const querySpec: SqlQuerySpec = {
                      *   query: "SELECT * FROM Families f WHERE f.lastName = @lastName",
                      *   parameters: [
                      *     {name: "@lastName", value: "Hendricks"}
                      *   ]
                      * };
                      * const {result: items} = await items.query(querySpec).fetchAll();
                      * ```
                      */
                     query(query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<any>;
                     /**
                      * Queries all items.
                      * @param query - Query configuration for the operation. See {@link SqlQuerySpec} for more info on how to configure a query.
                      * @param options - Used for modifying the request (for instance, specifying the partition key).
                      * @example Read all items to array.
                      * ```typescript
                      * const querySpec: SqlQuerySpec = {
                      *   query: "SELECT firstname FROM Families f WHERE f.lastName = @lastName",
                      *   parameters: [
                      *     {name: "@lastName", value: "Hendricks"}
                      *   ]
                      * };
                      * const {result: items} = await items.query<{firstName: string}>(querySpec).fetchAll();
                      * ```
                      */
                     query<T>(query: string | SqlQuerySpec, options?: FeedOptions): QueryIterator<T>;
                     /**
                      * Create a `ChangeFeedIterator` to iterate over pages of changes
                      *
                      * @deprecated Use `changeFeed` instead.
                      *
                      * @example Read from the beginning of the change feed.
                      * ```javascript
                      * const iterator = items.readChangeFeed({ startFromBeginning: true });
                      * const firstPage = await iterator.fetchNext();
                      * const firstPageResults = firstPage.result
                      * const secondPage = await iterator.fetchNext();
                      * ```
                      */
                     readChangeFeed(partitionKey: PartitionKey, changeFeedOptions?: ChangeFeedOptions): ChangeFeedIterator<any>;
                     /**
                      * Create a `ChangeFeedIterator` to iterate over pages of changes
                      * @deprecated Use `changeFeed` instead.
                      *
                      */
                     readChangeFeed(changeFeedOptions?: ChangeFeedOptions): ChangeFeedIterator<any>;
                     /**
                      * Create a `ChangeFeedIterator` to iterate over pages of changes
                      * @deprecated Use `changeFeed` instead.
                      */
                     readChangeFeed<T>(partitionKey: PartitionKey, changeFeedOptions?: ChangeFeedOptions): ChangeFeedIterator<T>;
                     /**
                      * Create a `ChangeFeedIterator` to iterate over pages of changes
                      * @deprecated Use `changeFeed` instead.
                      */
                     readChangeFeed<T>(changeFeedOptions?: ChangeFeedOptions): ChangeFeedIterator<T>;
                     /**
                      * Create a `ChangeFeedIterator` to iterate over pages of changes
                      *
                      * @example Read from the beginning of the change feed.
                      * ```javascript
                      * const iterator = items.readChangeFeed({ startFromBeginning: true });
                      * const firstPage = await iterator.fetchNext();
                      * const firstPageResults = firstPage.result
                      * const secondPage = await iterator.fetchNext();
                      * ```
                      */
                     changeFeed(partitionKey: PartitionKey, changeFeedOptions?: ChangeFeedOptions): ChangeFeedIterator<any>;
                     /**
                      * Create a `ChangeFeedIterator` to iterate over pages of changes
                      */
                     changeFeed(changeFeedOptions?: ChangeFeedOptions): ChangeFeedIterator<any>;
                     /**
                      * Create a `ChangeFeedIterator` to iterate over pages of changes
                      */
                     changeFeed<T>(partitionKey: PartitionKey, changeFeedOptions?: ChangeFeedOptions): ChangeFeedIterator<T>;
                     /**
                      * Create a `ChangeFeedIterator` to iterate over pages of changes
                      */
                     changeFeed<T>(changeFeedOptions?: ChangeFeedOptions): ChangeFeedIterator<T>;
                     /**
                      * Returns an iterator to iterate over pages of changes. The iterator returned can be used to fetch changes for a single partition key, feed range or an entire container.
                      */
                     getChangeFeedIterator<T>(changeFeedIteratorOptions?: ChangeFeedIteratorOptions): ChangeFeedPullModelIterator<T>;
                     /**
                      * Read all items.
                      *
                      * There is no set schema for JSON items. They may contain any number of custom properties.
                      *
                      * @param options - Used for modifying the request (for instance, specifying the partition key).
                      * @example Read all items to array.
                      * ```typescript
                      * const {body: containerList} = await items.readAll().fetchAll();
                      * ```
                      */
                     readAll(options?: FeedOptions): QueryIterator<ItemDefinition>;
                     /**
                      * Read all items.
                      *
                      * Any provided type, T, is not necessarily enforced by the SDK.
                      * You may get more or less properties and it's up to your logic to enforce it.
                      *
                      * There is no set schema for JSON items. They may contain any number of custom properties.
                      *
                      * @param options - Used for modifying the request (for instance, specifying the partition key).
                      * @example Read all items to array.
                      * ```typescript
                      * const {body: containerList} = await items.readAll().fetchAll();
                      * ```
                      */
                     readAll<T extends ItemDefinition>(options?: FeedOptions): QueryIterator<T>;
                     /**
                      * Create an item.
                      *
                      * Any provided type, T, is not necessarily enforced by the SDK.
                      * You may get more or less properties and it's up to your logic to enforce it.
                      *
                      * There is no set schema for JSON items. They may contain any number of custom properties.
                      *
                      * @param body - Represents the body of the item. Can contain any number of user defined properties.
                      * @param options - Used for modifying the request (for instance, specifying the partition key).
                      */
                     create<T extends ItemDefinition = any>(body: T, options?: RequestOptions): Promise<ItemResponse<T>>;
                     /**
                      * Upsert an item.
                      *
                      * There is no set schema for JSON items. They may contain any number of custom properties.
                      *
                      * @param body - Represents the body of the item. Can contain any number of user defined properties.
                      * @param options - Used for modifying the request (for instance, specifying the partition key).
                      */
                     upsert(body: unknown, options?: RequestOptions): Promise<ItemResponse<ItemDefinition>>;
                     /**
                      * Upsert an item.
                      *
                      * Any provided type, T, is not necessarily enforced by the SDK.
                      * You may get more or less properties and it's up to your logic to enforce it.
                      *
                      * There is no set schema for JSON items. They may contain any number of custom properties.
                      *
                      * @param body - Represents the body of the item. Can contain any number of user defined properties.
                      * @param options - Used for modifying the request (for instance, specifying the partition key).
                      */
                     upsert<T extends ItemDefinition>(body: T, options?: RequestOptions): Promise<ItemResponse<T>>;
                     /**
                      * Execute bulk operations on items.
                      *
                      * Bulk takes an array of Operations which are typed based on what the operation does.
                      * The choices are: Create, Upsert, Read, Replace, and Delete
                      *
                      * Usage example:
                      * ```typescript
                      * // partitionKey is optional at the top level if present in the resourceBody
                      * const operations: OperationInput[] = [
                      *    {
                      *       operationType: "Create",
                      *       resourceBody: { id: "doc1", name: "sample", key: "A" }
                      *    },
                      *    {
                      *       operationType: "Upsert",
                      *       partitionKey: 'A',
                      *       resourceBody: { id: "doc2", name: "other", key: "A" }
                      *    }
                      * ]
                      *
                      * await database.container.items.bulk(operations)
                      * ```
                      *
                      * @param operations - List of operations. Limit 100
                      * @param bulkOptions - Optional options object to modify bulk behavior. Pass \{ continueOnError: false \} to stop executing operations when one fails. (Defaults to true)
                      * @param options - Used for modifying the request.
                      */
                     bulk(operations: OperationInput[], bulkOptions?: BulkOptions, options?: RequestOptions): Promise<BulkOperationResponse>;
                     private executeBatchOperations;
                     /**
                      * Function to create new batches based of partition key Ranges.
                      *
                      * @param overlappingRanges - Overlapping partition key ranges.
                      * @param batch - Batch to be split.
                      * @param partitionKeyDefinition - PartitionKey definition of container.
                      * @returns Array of new batches.
                      */
                     private createNewBatches;
                     /**
                      * Function to create batches based of partition key Ranges.
                      * @param operations - operations to group
                      * @param partitionDefinition - PartitionKey definition of container.
                      * @param options - Request options for bulk request.
                      * @param batches - Groups to be filled with operations.
                      */
                     private groupOperationsBasedOnPartitionKey;
                     /**
                      * Execute transactional batch operations on items.
                      *
                      * Batch takes an array of Operations which are typed based on what the operation does. Batch is transactional and will rollback all operations if one fails.
                      * The choices are: Create, Upsert, Read, Replace, and Delete
                      *
                      * Usage example:
                      * ```typescript
                      * // The partitionKey is a required second argument. If it’s undefined, it defaults to the expected partition key format.
                      * const operations: OperationInput[] = [
                      *    {
                      *       operationType: "Create",
                      *       resourceBody: { id: "doc1", name: "sample", key: "A" }
                      *    },
                      *    {
                      *       operationType: "Upsert",
                      *       resourceBody: { id: "doc2", name: "other", key: "A" }
                      *    }
                      * ]
                      *
                      * await database.container.items.batch(operations, "A")
                      * ```
                      *
                      * @param operations - List of operations. Limit 100
                      * @param options - Used for modifying the request
                      */
                     batch(operations: OperationInput[], partitionKey?: PartitionKey, options?: RequestOptions): Promise<Response_2<OperationResponse[]>>;
                 }

                 export declare interface JSONArray extends ArrayLike<JSONValue> {
                 }

                 export declare interface JSONObject {
                     [key: string]: JSONValue;
                 }

                 export declare type JSONValue = boolean | number | string | null | JSONArray | JSONObject;

                 /**
                  * Used to specify the locations that are available, read is index 1 and write is index 0.
                  */
                 export declare interface Location {
                     name: string;
                     databaseAccountEndpoint: string;
                     unavailable?: boolean;
                     lastUnavailabilityTimestampInMs?: number;
                 }

                 /**
                  * This type contains diagnostic information regarding a single metadata request to server.
                  */
                 export declare interface MetadataLookUpDiagnostic {
                     activityId: string;
                     startTimeUTCInMs: number;
                     durationInMs: number;
                     operationType?: OperationType;
                     resourceType?: ResourceType;
                     metaDataType: MetadataLookUpType;
                     requestPayloadLengthInBytes: number;
                     responsePayloadLengthInBytes: number;
                 }

                 /**
                  * This type contains diagnostic information regarding all metadata request to server during an CosmosDB client operation.
                  */
                 export declare type MetadataLookUpDiagnostics = {
                     metadataLookups: MetadataLookUpDiagnostic[];
                 };

                 /**
                  * This is enum for Type of Metadata lookups possible.
                  */
                 export declare enum MetadataLookUpType {
                     PartitionKeyRangeLookUp = "PARTITION_KEY_RANGE_LOOK_UP",
                     DatabaseAccountLookUp = "DATABASE_ACCOUNT_LOOK_UP",
                     QueryPlanLookUp = "QUERY_PLAN_LOOK_UP",
                     DatabaseLookUp = "DATABASE_LOOK_UP",
                     ContainerLookUp = "CONTAINER_LOOK_UP"
                 }

                 /**
                  * Next is a function which takes in requestContext returns a promise. You must await/then that promise which will contain the response from further plugins,
                  * allowing you to log those results or handle errors.
                  * @hidden
                  */
                 export declare type Next<T> = (context: RequestContext) => Promise<Response_2<T>>;

                 /**
                  * The returned object represents a partition key value that allows creating and accessing items
                  * without a value for partition key
                  */
                 export declare type NonePartitionKeyType = {
                     [K in any]: never;
                 };

                 /**
                  * The returned object represents a partition key value that allows creating and accessing items
                  * with a null value for the partition key.
                  */
                 export declare type NullPartitionKeyType = null;

                 /**
                  * Use to read or replace an existing {@link Offer} by id.
                  *
                  * @see {@link Offers} to query or read all offers.
                  */
                 export declare class Offer {
                     readonly client: CosmosClient;
                     readonly id: string;
                     private readonly clientContext;
                     /**
                      * Returns a reference URL to the resource. Used for linking in Permissions.
                      */
                     get url(): string;
                     /**
                      * @hidden
                      * @param client - The parent {@link CosmosClient} for the Database Account.
                      * @param id - The id of the given {@link Offer}.
                      */
                     constructor(client: CosmosClient, id: string, clientContext: ClientContext);
                     /**
                      * Read the {@link OfferDefinition} for the given {@link Offer}.
                      */
                     read(options?: RequestOptions): Promise<OfferResponse>;
                     /**
                      * Replace the given {@link Offer} with the specified {@link OfferDefinition}.
                      * @param body - The specified {@link OfferDefinition}
                      */
                     replace(body: OfferDefinition, options?: RequestOptions): Promise<OfferResponse>;
                 }

                 export declare interface OfferDefinition {
                     id?: string;
                     offerType?: string;
                     offerVersion?: string;
                     resource?: string;
                     offerResourceId?: string;
                     content?: {
                         offerThroughput: number;
                         offerIsRUPerMinuteThroughputEnabled: boolean;
                         offerMinimumThroughputParameters?: {
                             maxThroughputEverProvisioned: number;
                             maxConsumedStorageEverInKB: number;
                         };
                         offerAutopilotSettings?: {
                             tier: number;
                             maximumTierThroughput: number;
                             autoUpgrade: boolean;
                             maxThroughput: number;
                         };
                     };
                 }

                 export declare class OfferResponse extends ResourceResponse<OfferDefinition & Resource> {
                     constructor(resource: OfferDefinition & Resource, headers: CosmosHeaders, statusCode: number, diagnostics: CosmosDiagnostics, offer?: Offer);
                     /** A reference to the {@link Offer} corresponding to the returned {@link OfferDefinition}. */
                     readonly offer: Offer;
                 }

                 /**
                  * Use to query or read all Offers.
                  *
                  * @see {@link Offer} to read or replace an existing {@link Offer} by id.
                  */
                 export declare class Offers {