couchbase

  • Version 4.4.4
  • Published
  • 36.4 MB
  • 2 dependencies
  • Apache-2.0 license

Install

npm i couchbase
yarn add couchbase
pnpm add couchbase

Overview

The official Couchbase Node.js Client Library.

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable cbppMetadata

const cbppMetadata: string;

    variable cbppVersion

    const cbppVersion: string;
    • Exposes the underlying couchbase++ library version that is being used by the SDK to perform I/O with the cluster.

    variable lcbVersion

    const lcbVersion: string;
    • Exposes the underlying couchbase++ library version that is being used by the SDK to perform I/O with the cluster.

      Deprecated

      Use cbppVersion instead.

    Functions

    function connect

    connect: (
    connStr: string,
    options?: ConnectOptions,
    callback?: NodeCallback<Cluster>
    ) => Promise<Cluster>;
    • Acts as the entrypoint into the rest of the library. Connecting to the cluster and exposing the various services and features.

      Parameter connStr

      The connection string to use to connect to the cluster.

      Parameter options

      Optional parameters for this operation.

      Parameter callback

      A node-style callback to be invoked after execution. Core

    function enableProtocolLoggerToSaveNetworkTrafficToFile

    enableProtocolLoggerToSaveNetworkTrafficToFile: (filename: string) => void;
    • Volatile: This API is subject to change at any time.

      Exposes the underlying couchbase++ library protocol logger. This method is for logging/debugging purposes and must be used with caution as network details will be logged to the provided file.

      Parameter filename

      Name of file protocol logger will save logging details.

    function shutdownLogger

    shutdownLogger: () => void;
    • Volatile: This API is subject to change at any time.

      Shutdowns the underlying couchbase++ logger.

    Classes

    class AmbiguousTimeoutError

    class AmbiguousTimeoutError extends TimeoutError {}
    • Indicates that an ambiguous timeout has occured. The outcome of the operation is unknown, and it is possible that it completed after the generation of this error.

      Error Handling

    constructor

    constructor(cause?: Error, context?: ErrorContext);

      class AnalyticsDataset

      class AnalyticsDataset {}
      • Contains a specific dataset configuration for the analytics service.

        Management

      property bucketName

      bucketName: string;
      • The name of the bucket that this dataset includes.

      property dataverseName

      dataverseName: string;
      • The name of the dataverse that this dataset exists within.

      property linkName

      linkName: string;
      • The name of the link that is associated with this dataset.

      property name

      name: string;
      • The name of the dataset.

      class AnalyticsErrorContext

      class AnalyticsErrorContext extends ErrorContext {}
      • The error context information for an analytics query operation.

        Error Handling

      property client_context_id

      client_context_id: string;
      • The client context id which was sent to the service for correlation between requests and responses.

      property http_response_body

      http_response_body: string;
      • The http response body which was received.

      property http_response_code

      http_response_code: number;
      • The http response status code which was received.

      property parameters

      parameters: any;
      • A list of the parameters in use for the operation.

      property statement

      statement: string;
      • The statement that was being executed when the error occured.

      class AnalyticsIndex

      class AnalyticsIndex {}
      • Contains a specific index configuration for the analytics service.

        Management

      property datasetName

      datasetName: string;
      • The name of the dataset this index belongs to.

      property dataverseName

      dataverseName: string;
      • The name of the dataverse this index belongs to.

      property isPrimary

      isPrimary: boolean;
      • Whether or not this is a primary index or not.

      property name

      name: string;
      • The name of the index.

      class AnalyticsIndexManager

      class AnalyticsIndexManager {}
      • AnalyticsIndexManager provides an interface for performing management operations against the analytics service of the cluster.

        Management

      connectLink: {
      (
      linkStr: string,
      options?: ConnectAnalyticsLinkOptions,
      callback?: NodeCallback<void>
      ): Promise<void>;
      (
      options?: ConnectAnalyticsLinkOptions,
      callback?: NodeCallback<void>
      ): Promise<void>;
      };
      • Connects a not yet connected link.

        Parameter linkStr

        The name of the link to connect.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

        Deprecated

        Use the other overload instead.

      • Connects a not yet connected link.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method createDataset

      createDataset: (
      bucketName: string,
      datasetName: string,
      options?: CreateAnalyticsDatasetOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Creates a new dataset.

        Parameter bucketName

        The name of the bucket to create this dataset of.

        Parameter datasetName

        The name of the new dataset.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method createDataverse

      createDataverse: (
      dataverseName: string,
      options?: CreateAnalyticsDataverseOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Creates a new dataverse.

        Parameter dataverseName

        The name of the dataverse to create.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method createIndex

      createIndex: (
      datasetName: string,
      indexName: string,
      fields: { [key: string]: string },
      options?: CreateAnalyticsIndexOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Creates a new index.

        Parameter datasetName

        The name of the dataset to create this index on.

        Parameter indexName

        The name of index to create.

        Parameter fields

        A map of fields that the index should contain.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      createLink: (
      link: IAnalyticsLink,
      options?: CreateAnalyticsLinkOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Creates a new analytics remote link.

        Parameter link

        The settings for the link to create.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      disconnectLink: {
      (
      linkStr: string,
      options?: DisconnectAnalyticsLinkOptions,
      callback?: NodeCallback<void>
      ): Promise<void>;
      (
      options?: DisconnectAnalyticsLinkOptions,
      callback?: NodeCallback<void>
      ): Promise<void>;
      };
      • Disconnects a previously connected link.

        Parameter linkStr

        The name of the link to disconnect.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

        Deprecated

        Use the other overload instead.

      • Disconnects a previously connected link.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method dropDataset

      dropDataset: (
      datasetName: string,
      options?: DropAnalyticsDatasetOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Drops a previously created dataset.

        Parameter datasetName

        The name of the dataset to drop.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method dropDataverse

      dropDataverse: (
      dataverseName: string,
      options?: DropAnalyticsDataverseOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Drops a previously created dataverse.

        Parameter dataverseName

        The name of the dataverse to drop.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method dropIndex

      dropIndex: (
      datasetName: string,
      indexName: string,
      options?: DropAnalyticsIndexOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Drops a previously created index.

        Parameter datasetName

        The name of the dataset containing the index to drop.

        Parameter indexName

        The name of the index to drop.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      dropLink: (
      linkName: string,
      dataverseName: string,
      options?: DropAnalyticsLinkOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Drops an existing analytics remote link.

        Parameter linkName

        The name of the link to drop.

        Parameter dataverseName

        The dataverse containing the link to drop.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method getAllDatasets

      getAllDatasets: (
      options?: GetAllAnalyticsDatasetsOptions,
      callback?: NodeCallback<AnalyticsDataset[]>
      ) => Promise<AnalyticsDataset[]>;
      • Returns a list of all existing datasets.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method getAllIndexes

      getAllIndexes: (
      options?: GetAllAnalyticsIndexesOptions,
      callback?: NodeCallback<AnalyticsIndex[]>
      ) => Promise<AnalyticsIndex[]>;
      • Returns a list of all existing indexes.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      getAllLinks: (
      options?: GetAllAnalyticsLinksOptions,
      callback?: NodeCallback<AnalyticsLink[]>
      ) => Promise<AnalyticsLink[]>;
      • Returns a list of existing analytics remote links.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      method getPendingMutations

      getPendingMutations: (
      options?: GetPendingAnalyticsMutationsOptions,
      callback?: NodeCallback<{ [k: string]: { [k: string]: number } }>
      ) => Promise<{ [k: string]: { [k: string]: number } }>;
      • Returns a list of all pending mutations.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      replaceLink: (
      link: IAnalyticsLink,
      options?: ReplaceAnalyticsLinkOptions,
      callback?: NodeCallback<void>
      ) => Promise<void>;
      • Replaces an existing analytics remote link.

        Parameter link

        The settings for the updated link.

        Parameter options

        Optional parameters for this operation.

        Parameter callback

        A node-style callback to be invoked after execution.

      abstract class AnalyticsLink implements IAnalyticsLink {}
      • This is a base class for specific link configurations for the analytics service.

      property dataverse

      dataverse: string;
      • The dataverse that this link belongs to.

      property linkType

      linkType: AnalyticsLinkType;
      • Specifies what type of analytics link this represents.

      property name

      name: string;
      • The name of this link.

      method validate

      abstract validate: () => void;
      • Validates the link.

      class AnalyticsMetaData

      class AnalyticsMetaData {}
      • Contains the meta-data that is returend from an analytics query.

        Analytics

      property clientContextId

      clientContextId: string;
      • The client context id which is assoicated with the executed query.

      property metrics

      metrics: AnalyticsMetrics;
      • Various metrics which are made available by the query engine.

      property requestId

      requestId: string;
      • The request ID which is associated with the executed query.

      property signature

      signature?: any;
      • Provides the signature of the query.

      property status

      status: AnalyticsStatus;
      • The status of the query at the time the query meta-data was generated.

      property warnings

      warnings: AnalyticsWarning[];
      • Any warnings that occurred during the execution of the query.

      class AnalyticsMetrics

      class AnalyticsMetrics {}
      • Contains various metrics that are returned by the server following the execution of an analytics query.

        Analytics

      property elapsedTime

      elapsedTime: number;
      • The total amount of time spent running the query, in milliseconds.

      property errorCount

      errorCount: number;
      • The total number of errors which were encountered during the execution of the query.

      property executionTime

      executionTime: number;
      • The total amount of time spent executing the query, in milliseconds.

      property processedObjects

      processedObjects: number;
      • The total number of objects that were processed as part of execution of the query.

      property resultCount

      resultCount: number;
      • The total number of rows which were part of the result set.

      property resultSize

      resultSize: number;
      • The total number of bytes which were generated as part of the result set.

      property warningCount

      warningCount: number;
      • The total number of warnings which were encountered during the execution of the query.

      class AnalyticsResult

      class AnalyticsResult<TRow = any> {}
      • Contains the results of an analytics query.

        Analytics

      property meta

      meta: AnalyticsMetaData;
      • The meta-data which has been returned by the query.

      property rows

      rows: TRow[];
      • The rows which have been returned by the query.

      class AnalyticsWarning

      class AnalyticsWarning {}
      • Contains information about a warning which occurred during the execution of an analytics query.

        Analytics

      property code

      code: number;
      • The numeric code associated with the warning which occurred.

      property message

      message: string;
      • A human readable representation of the warning which occurred.

      class AuthenticationFailureError

      class AuthenticationFailureError extends CouchbaseError {}
      • Indicates that an error occurred authenticating the user to the cluster.

        Error Handling

      constructor

      constructor(cause?: Error, context?: ErrorContext);
        class AzureExternalAnalyticsLink
        extends AnalyticsLink
        implements IAzureExternalAnalyticsLink {}
        • Provides information about a analytics remote S3 link.

        property accountKey

        accountKey?: string;
        • The Azure blob storage account key.

        property accountName

        accountName?: string;
        • The Azure blob storage account name.

        property blobEndpoint

        blobEndpoint?: string;
        • The Azure blob storage endpoint.

        property connectionString

        connectionString?: string;
        • The connection string to use to connect to the external Azure store.

        property dataverse

        dataverse: string;
        • The dataverse that this link belongs to.

        property endpointSuffix

        endpointSuffix?: string;
        • The Azure blob endpoint suffix.

        property linkType

        linkType: string;
        • Specifies what type of analytics link this represents.

        property name

        name: string;
        • The name of this link.

        property sharedAccessSignature

        sharedAccessSignature?: string;
        • The shared access signature to use for authentication.

        method validate

        validate: () => void;
        • Validates the AzureExternalAnalyticsLink.

        class BinaryCollection

        class BinaryCollection {}
        • Exposes a number of binary-level operations against a collection. These operations do not adhere to the standard JSON-centric behaviour of the SDK.

          Core

        method append

        append: (
        key: string,
        value: string | Buffer,
        options?: AppendOptions,
        callback?: NodeCallback<MutationResult>
        ) => Promise<MutationResult>;
        • Appends the specified value to the end of the specified key.

          Parameter key

          The key to append to.

          Parameter value

          The value to adjoin to the end of the document.

          Parameter options

          Optional parameters for this operation.

          Parameter callback

          A node-style callback to be invoked after execution.

        method decrement

        decrement: (
        key: string,
        delta: number,
        options?: DecrementOptions,
        callback?: NodeCallback<CounterResult>
        ) => Promise<CounterResult>;
        • Decrements the ASCII value of the specified key by the amount indicated in the delta parameter.

          Parameter key

          The key to increment.

          Parameter delta

          The amount to increment the key.

          Parameter options

          Optional parameters for this operation.

          Parameter callback

          A node-style callback to be invoked after execution.

        method increment

        increment: (
        key: string,
        delta: number,
        options?: IncrementOptions,
        callback?: NodeCallback<CounterResult>
        ) => Promise<CounterResult>;
        • Increments the ASCII value of the specified key by the amount indicated in the delta parameter.

          Parameter key

          The key to increment.

          Parameter delta

          The amount to increment the key.

          Parameter options

          Optional parameters for this operation.

          Parameter callback

          A node-style callback to be invoked after execution.

        method prepend

        prepend: (
        key: string,
        value: string | Buffer,
        options?: PrependOptions,
        callback?: NodeCallback<MutationResult>
        ) => Promise<MutationResult>;
        • Prepends the specified value to the beginning of the specified key.

          Parameter key

          The key to prepend to.

          Parameter value

          The value to adjoin to the beginning of the document.

          Parameter options

          Optional parameters for this operation.

          Parameter callback

          A node-style callback to be invoked after execution.

        class BooleanFieldSearchQuery

        class BooleanFieldSearchQuery extends SearchQuery {}
        • Represents a boolean-field search query.

          Full Text Search

        method boost

        boost: (boost: number) => BooleanFieldSearchQuery;

          method field

          field: (field: string) => BooleanFieldSearchQuery;

            class BooleanSearchQuery

            class BooleanSearchQuery extends SearchQuery {}
            • Represents a boolean search query.

              Full Text Search

            method boost

            boost: (boost: number) => BooleanSearchQuery;

              method must

              must: (query: ConjunctionSearchQuery) => BooleanSearchQuery;

                method mustNot

                mustNot: (query: DisjunctionSearchQuery) => BooleanSearchQuery;

                  method should

                  should: (query: DisjunctionSearchQuery) => BooleanSearchQuery;

                    method shouldMin

                    shouldMin: (shouldMin: number) => BooleanSearchQuery;

                      method toJSON

                      toJSON: () => any;

                        class Bucket

                        class Bucket {}
                        • Exposes the operations which are available to be performed against a bucket. Namely the ability to access to Collections as well as performing management operations against the bucket.

                          Core

                        property name

                        readonly name: string;
                        • The name of the bucket this Bucket object references.

                        method collection

                        collection: (collectionName: string) => Collection;
                        • Creates a Collection object reference to a specific collection.

                          Parameter collectionName

                          The name of the collection to reference.

                        method collections

                        collections: () => CollectionManager;
                        • Returns a CollectionManager which can be used to manage the collections of this bucket.

                        method defaultCollection

                        defaultCollection: () => Collection;
                        • Creates a Collection object reference to the default collection.

                        method defaultScope

                        defaultScope: () => Scope;
                        • Creates a Scope object reference to the default scope.

                        method ping

                        ping: (
                        options?: PingOptions,
                        callback?: NodeCallback<PingResult>
                        ) => Promise<PingResult>;
                        • Performs a ping operation against the cluster. Pinging the bucket services which are specified (or all services if none are specified). Returns a report which describes the outcome of the ping operations which were performed.

                          Parameter options

                          Optional parameters for this operation.

                          Parameter callback

                          A node-style callback to be invoked after execution.

                        method scope

                        scope: (scopeName: string) => Scope;
                        • Creates a Scope object reference to a specific scope.

                          Parameter scopeName

                          The name of the scope to reference.

                        method viewIndexes

                        viewIndexes: () => ViewIndexManager;
                        • Returns a ViewIndexManager which can be used to manage the view indexes of this bucket.

                        method viewQuery

                        viewQuery: <TValue = any, TKey = any>(
                        designDoc: string,
                        viewName: string,
                        options?: ViewQueryOptions,
                        callback?: NodeCallback<ViewResult<TValue, TKey>>
                        ) => StreamableRowPromise<
                        ViewResult<TValue, TKey>,
                        ViewRow<TValue, TKey>,
                        ViewMetaData
                        >;
                        • Executes a view query.

                          Parameter designDoc

                          The name of the design document containing the view to execute.

                          Parameter viewName

                          The name of the view to execute.

                          Parameter options

                          Optional parameters for this operation.

                          Parameter callback

                          A node-style callback to be invoked after execution.

                        class BucketExistsError

                        class BucketExistsError extends CouchbaseError {}
                        • Indicates that the referenced bucket already exists, but the operation expected it to not exist.

                          Error Handling

                        constructor

                        constructor(cause?: Error, context?: ErrorContext);

                          class BucketManager

                          class BucketManager {}
                          • BucketManager provides an interface for adding/removing/updating buckets within the cluster.

                            Management

                          method createBucket

                          createBucket: (
                          settings: ICreateBucketSettings,
                          options?: CreateBucketOptions,
                          callback?: NodeCallback<void>
                          ) => Promise<void>;
                          • Creates a new bucket.

                            Parameter settings

                            The settings to use for the new bucket.

                            Parameter options

                            Optional parameters for this operation.

                            Parameter callback

                            A node-style callback to be invoked after execution.

                          method dropBucket

                          dropBucket: (
                          bucketName: string,
                          options?: DropBucketOptions,
                          callback?: NodeCallback<void>
                          ) => Promise<void>;
                          • Drops an existing bucket.

                            Parameter bucketName

                            The name of the bucket to drop.

                            Parameter options

                            Optional parameters for this operation.

                            Parameter callback

                            A node-style callback to be invoked after execution.

                          method flushBucket

                          flushBucket: (
                          bucketName: string,
                          options?: FlushBucketOptions,
                          callback?: NodeCallback<void>
                          ) => Promise<void>;
                          • Flushes the bucket, deleting all the existing data that is stored in it.

                            Parameter bucketName

                            The name of the bucket to flush.

                            Parameter options

                            Optional parameters for this operation.

                            Parameter callback

                            A node-style callback to be invoked after execution.

                          method getAllBuckets

                          getAllBuckets: (
                          options?: GetAllBucketsOptions,
                          callback?: NodeCallback<BucketSettings[]>
                          ) => Promise<BucketSettings[]>;
                          • Returns a list of existing buckets in the cluster.

                            Parameter options

                            Optional parameters for this operation.

                            Parameter callback

                            A node-style callback to be invoked after execution.

                          method getBucket

                          getBucket: (
                          bucketName: string,
                          options?: GetBucketOptions,
                          callback?: NodeCallback<BucketSettings>
                          ) => Promise<BucketSettings>;
                          • Fetches the settings in use for a specified bucket.

                            Parameter bucketName

                            The name of the bucket to fetch settings for.

                            Parameter options

                            Optional parameters for this operation.

                            Parameter callback

                            A node-style callback to be invoked after execution.

                          method updateBucket

                          updateBucket: (
                          settings: BucketSettings,
                          options?: UpdateBucketOptions,
                          callback?: NodeCallback<void>
                          ) => Promise<void>;
                          • Updates the settings for an existing bucket.

                            Parameter settings

                            The new settings to use for the bucket.

                            Parameter options

                            Optional parameters for this operation.

                            Parameter callback

                            A node-style callback to be invoked after execution.

                          class BucketNotFlushableError

                          class BucketNotFlushableError extends CouchbaseError {}
                          • Indicates that the bucket could not be flushed due to not having the flush option enabled. This option can be dynamically adjusted.

                            Error Handling

                          constructor

                          constructor(cause?: Error, context?: ErrorContext);

                            class BucketNotFoundError

                            class BucketNotFoundError extends CouchbaseError {}
                            • Indicates that the bucket being referenced does not exist.

                              Error Handling

                            constructor

                            constructor(cause?: Error, context?: ErrorContext);

                              class BucketSettings

                              class BucketSettings implements IBucketSettings {}
                              • Represents the configured options for a bucket.

                                Management

                              property bucketType

                              bucketType?: BucketType;
                              • Specifies the type of bucket that should be used.

                              property compressionMode

                              compressionMode?: CompressionMode;
                              • Specifies the compression mode that should be used.

                              property durabilityMinLevel

                              readonly durabilityMinLevel: string;

                              property ejectionMethod

                              ejectionMethod: string;

                              property evictionPolicy

                              evictionPolicy?: EvictionPolicy;
                              • Specifies the ejection method that should be used.

                              property flushEnabled

                              flushEnabled?: boolean;
                              • Whether the flush operation (truncating all data in the bucket) should be enabled.

                              property historyRetentionBytes

                              historyRetentionBytes?: number;
                              • Specifies the maximum history retention in bytes on all collections in this bucket.

                              property historyRetentionCollectionDefault

                              historyRetentionCollectionDefault?: boolean;
                              • Specifies the default history retention on all collections in this bucket. Only available on Magma Buckets.

                                See Also

                              property historyRetentionDuration

                              historyRetentionDuration?: number;
                              • Specifies the maximum duration in seconds to be covered by the change history that is written to disk for all collections in this bucket.

                              property maxExpiry

                              maxExpiry?: number;
                              • Specifies the maximum expiry time that any document should be permitted to have. Any documents stored with an expiry configured higher than this will be forced to this number.

                              property maxTTL

                              maxTTL: number;

                              property minimumDurabilityLevel

                              minimumDurabilityLevel?: DurabilityLevel;
                              • Specifies the minimum durability level that should be used for any write operations which are performed against this bucket.

                              property name

                              name: string;
                              • The name of the bucket.

                              property numReplicas

                              numReplicas?: number;
                              • The number of replicas that should exist for this bucket.

                              property ramQuotaMB

                              ramQuotaMB: number;
                              • The amount of RAM which should be allocated to this bucket, expressed in megabytes.

                              property replicaIndexes

                              replicaIndexes?: boolean;
                              • Whether the indexes on this bucket should be replicated.

                              property storageBackend

                              storageBackend?: string;
                              • Specifies the storage backend to use for the bucket.

                              class CasMismatchError

                              class CasMismatchError extends CouchbaseError {}
                              • Indicates that a CAS mismatch occurred. This means that the document has changed since the last access and should be fetched again before attempting to make further changes.

                                Error Handling

                              constructor

                              constructor(cause?: Error, context?: ErrorContext);

                                class CertificateAuthenticator

                                class CertificateAuthenticator implements ICertificateAuthenticator {}
                                • CertificateAuthenticator implements a simple ICertificateAuthenticator.

                                  Authentication

                                constructor

                                constructor(certificatePath: string, keyPath: string);
                                • Constructs this CertificateAuthenticator with the passed certificate and key paths.

                                  Parameter certificatePath

                                  The certificate path to initialize this authenticator with.

                                  Parameter keyPath

                                  The key path to initialize this authenticator with.

                                property certificatePath

                                certificatePath: string;
                                • The path to the certificate which should be used for certificate authentication.

                                property keyPath

                                keyPath: string;
                                • The path to the key which should be used for certificate authentication.

                                class Cluster

                                class Cluster {}
                                • Exposes the operations which are available to be performed against a cluster. Namely the ability to access to Buckets as well as performing management operations against the cluster.

                                  Core

                                method analyticsIndexes

                                analyticsIndexes: () => AnalyticsIndexManager;
                                • Returns a AnalyticsIndexManager which can be used to manage the analytics indexes of this cluster.

                                method analyticsQuery

                                analyticsQuery: <TRow = any>(
                                statement: string,
                                options?: AnalyticsQueryOptions,
                                callback?: NodeCallback<AnalyticsResult<TRow>>
                                ) => StreamableRowPromise<AnalyticsResult<TRow>, TRow, AnalyticsMetaData>;
                                • Executes an analytics query against the cluster.

                                  Parameter statement

                                  The analytics statement to execute.

                                  Parameter options

                                  Optional parameters for this operation.

                                  Parameter callback

                                  A node-style callback to be invoked after execution.

                                method bucket

                                bucket: (bucketName: string) => Bucket;
                                • Creates a Bucket object reference to a specific bucket.

                                  Parameter bucketName

                                  The name of the bucket to reference.

                                method buckets

                                buckets: () => BucketManager;
                                • Returns a BucketManager which can be used to manage the buckets of this cluster.

                                method close

                                close: (callback?: NodeCallback<void>) => Promise<void>;
                                • Shuts down this cluster object. Cleaning up all resources associated with it.

                                  Parameter callback

                                  A node-style callback to be invoked after execution.

                                method diagnostics

                                diagnostics: (
                                options?: DiagnosticsOptions,
                                callback?: NodeCallback<DiagnosticsResult>
                                ) => Promise<DiagnosticsResult>;
                                • Returns a diagnostics report about the currently active connections with the cluster. Includes information about remote and local addresses, last activity, and other diagnostics information.

                                  Parameter options

                                  Optional parameters for this operation.

                                  Parameter callback

                                  A node-style callback to be invoked after execution.

                                method eventingFunctions

                                eventingFunctions: () => EventingFunctionManager;
                                • Returns a EventingFunctionManager which can be used to manage the eventing functions of this cluster. Uncommitted: This API is subject to change in the future.

                                method ping

                                ping: (
                                options?: PingOptions,
                                callback?: NodeCallback<PingResult>
                                ) => Promise<PingResult>;
                                • Performs a ping operation against the cluster. Pinging the services which are specified (or all services if none are specified). Returns a report which describes the outcome of the ping operations which were performed.

                                  Parameter options

                                  Optional parameters for this operation.

                                  Parameter callback

                                  A node-style callback to be invoked after execution.

                                method query

                                query: <TRow = any>(
                                statement: string,
                                options?: QueryOptions,
                                callback?: NodeCallback<QueryResult<TRow>>
                                ) => StreamableRowPromise<QueryResult<TRow>, TRow, QueryMetaData>;
                                • Executes a N1QL query against the cluster.

                                  Parameter statement

                                  The N1QL statement to execute.

                                  Parameter options

                                  Optional parameters for this operation.

                                  Parameter callback

                                  A node-style callback to be invoked after execution.

                                method queryIndexes

                                queryIndexes: () => QueryIndexManager;
                                • Returns a QueryIndexManager which can be used to manage the query indexes of this cluster.

                                method search

                                search: (
                                indexName: string,
                                request: SearchRequest,
                                options?: SearchQueryOptions,
                                callback?: NodeCallback<SearchResult>
                                ) => StreamableRowPromise<SearchResult, SearchRow, SearchMetaData>;
                                • Executes a search query against the cluster.

                                  Parameter indexName

                                  The name of the index to query.

                                  Parameter request

                                  The SearchRequest describing the search to execute.

                                  Parameter options

                                  Optional parameters for this operation.

                                  Parameter callback

                                  A node-style callback to be invoked after execution.

                                method searchIndexes

                                searchIndexes: () => SearchIndexManager;
                                • Returns a SearchIndexManager which can be used to manage the search indexes of this cluster.

                                method searchQuery

                                searchQuery: (
                                indexName: string,
                                query: SearchQuery,
                                options?: SearchQueryOptions,
                                callback?: NodeCallback<SearchResult>
                                ) => StreamableRowPromise<SearchResult, SearchRow, SearchMetaData>;
                                • Executes a search query against the cluster.

                                  Parameter indexName

                                  The name of the index to query.

                                  Parameter query

                                  The SearchQuery describing the query to execute.

                                  Parameter options

                                  Optional parameters for this operation.

                                  Parameter callback

                                  A node-style callback to be invoked after execution.

                                method transactions

                                transactions: () => Transactions;
                                • Returns a Transactions object which can be used to perform transactions on this cluster.

                                method users

                                users: () => UserManager;
                                • Returns a UserManager which can be used to manage the users of this cluster.

                                class ClusterClosedError

                                class ClusterClosedError extends CouchbaseError {}
                                • Indicates that an operation was performed after the cluster object was explicitly closed by the user.

                                  Error Handling

                                constructor

                                constructor();

                                  class Collection

                                  class Collection {}
                                  • Exposes the operations which are available to be performed against a collection. Namely the ability to perform KV operations.

                                    Core

                                  property name

                                  readonly name: string;
                                  • The name of the collection this Collection object references.

                                  method binary

                                  binary: () => BinaryCollection;
                                  • Returns a BinaryCollection object reference, allowing access to various binary operations possible against a collection.

                                  method exists

                                  exists: (
                                  key: string,
                                  options?: ExistsOptions,
                                  callback?: NodeCallback<ExistsResult>
                                  ) => Promise<ExistsResult>;
                                  • Checks whether a specific document exists or not.

                                    Parameter key

                                    The document key to check for existence.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method get

                                  get: (
                                  key: string,
                                  options?: GetOptions,
                                  callback?: NodeCallback<GetResult>
                                  ) => Promise<GetResult>;
                                  • Retrieves the value of a document from the collection.

                                    Parameter key

                                    The document key to retrieve.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method getAllReplicas

                                  getAllReplicas: (
                                  key: string,
                                  options?: GetAllReplicasOptions,
                                  callback?: NodeCallback<GetReplicaResult[]>
                                  ) => Promise<GetReplicaResult[]>;
                                  • Retrieves the value of the document from all available replicas. Note that as replication is asynchronous, each node may return a different value.

                                    Parameter key

                                    The document key to retrieve.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method getAndLock

                                  getAndLock: (
                                  key: string,
                                  lockTime: number,
                                  options?: GetAndLockOptions,
                                  callback?: NodeCallback<GetResult>
                                  ) => Promise<GetResult>;
                                  • Locks a document and retrieves the value of that document at the time it is locked.

                                    Parameter key

                                    The document key to retrieve and lock.

                                    Parameter lockTime

                                    The amount of time to lock the document for, specified in seconds.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method getAndTouch

                                  getAndTouch: (
                                  key: string,
                                  expiry: number,
                                  options?: GetAndTouchOptions,
                                  callback?: NodeCallback<GetResult>
                                  ) => Promise<GetResult>;
                                  • Retrieves the value of the document and simultanously updates the expiry time for the same document.

                                    Parameter key

                                    The document to fetch and touch.

                                    Parameter expiry

                                    The new expiry to apply to the document, specified in seconds.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method getAnyReplica

                                  getAnyReplica: (
                                  key: string,
                                  options?: GetAnyReplicaOptions,
                                  callback?: NodeCallback<GetReplicaResult>
                                  ) => Promise<GetReplicaResult>;
                                  • Retrieves the value of the document from any of the available replicas. This will return as soon as the first response is received from any replica node.

                                    Parameter key

                                    The document key to retrieve.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method insert

                                  insert: (
                                  key: string,
                                  value: any,
                                  options?: InsertOptions,
                                  callback?: NodeCallback<MutationResult>
                                  ) => Promise<MutationResult>;
                                  • Inserts a new document to the collection, failing if the document already exists.

                                    Parameter key

                                    The document key to insert.

                                    Parameter value

                                    The value of the document to insert.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method list

                                  list: (key: string) => CouchbaseList;
                                  • Returns a CouchbaseList permitting simple list storage in a document.

                                    Parameter key

                                    The document key the data-structure resides in.

                                  method lookupIn

                                  lookupIn: (
                                  key: string,
                                  specs: LookupInSpec[],
                                  options?: LookupInOptions,
                                  callback?: NodeCallback<LookupInResult>
                                  ) => Promise<LookupInResult>;
                                  • Performs a lookup-in operation against a document, fetching individual fields or information about specific fields inside the document value.

                                    Parameter key

                                    The document key to look in.

                                    Parameter specs

                                    A list of specs describing the data to fetch from the document.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method lookupInAllReplicas

                                  lookupInAllReplicas: (
                                  key: string,
                                  specs: LookupInSpec[],
                                  options?: LookupInOptions,
                                  callback?: NodeCallback<LookupInReplicaResult[]>
                                  ) => Promise<LookupInReplicaResult[]>;
                                  • Performs a lookup-in operation against a document, fetching individual fields or information about specific fields inside the document value from all available replicas. Note that as replication is asynchronous, each node may return a different value.

                                    Parameter key

                                    The document key to look in.

                                    Parameter specs

                                    A list of specs describing the data to fetch from the document.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method lookupInAnyReplica

                                  lookupInAnyReplica: (
                                  key: string,
                                  specs: LookupInSpec[],
                                  options?: LookupInOptions,
                                  callback?: NodeCallback<LookupInReplicaResult>
                                  ) => Promise<LookupInReplicaResult>;
                                  • Performs a lookup-in operation against a document, fetching individual fields or information about specific fields inside the document value from any of the available replicas in the cluster.

                                    Parameter key

                                    The document key to look in.

                                    Parameter specs

                                    A list of specs describing the data to fetch from the document.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method map

                                  map: (key: string) => CouchbaseMap;
                                  • Returns a CouchbaseMap permitting simple map storage in a document.

                                    Parameter key

                                    The document key the data-structure resides in.

                                  method mutateIn

                                  mutateIn: (
                                  key: string,
                                  specs: MutateInSpec[],
                                  options?: MutateInOptions,
                                  callback?: NodeCallback<MutateInResult>
                                  ) => Promise<MutateInResult>;
                                  • Performs a mutate-in operation against a document. Allowing atomic modification of specific fields within a document. Also enables access to document extended-attributes.

                                    Parameter key

                                    The document key to mutate.

                                    Parameter specs

                                    A list of specs describing the operations to perform on the document.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method queryIndexes

                                  queryIndexes: () => CollectionQueryIndexManager;
                                  • Returns a CollectionQueryIndexManager which can be used to manage the query indexes of this collection.

                                  method queue

                                  queue: (key: string) => CouchbaseQueue;
                                  • Returns a CouchbaseQueue permitting simple queue storage in a document.

                                    Parameter key

                                    The document key the data-structure resides in.

                                  method remove

                                  remove: (
                                  key: string,
                                  options?: RemoveOptions,
                                  callback?: NodeCallback<MutationResult>
                                  ) => Promise<MutationResult>;
                                  • Remove an existing document from the collection.

                                    Parameter key

                                    The document key to remove.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method replace

                                  replace: (
                                  key: string,
                                  value: any,
                                  options?: ReplaceOptions,
                                  callback?: NodeCallback<MutationResult>
                                  ) => Promise<MutationResult>;
                                  • Replaces the value of an existing document. Failing if the document does not exist.

                                    Parameter key

                                    The document key to replace.

                                    Parameter value

                                    The new value for the document.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method scan

                                  scan: (
                                  scanType: RangeScan | SamplingScan | PrefixScan,
                                  options?: ScanOptions,
                                  callback?: NodeCallback<ScanResult[]>
                                  ) => Promise<ScanResult[]>;
                                  • Performs a key-value scan operation.

                                    Use this API for low concurrency batch queries where latency is not a critical as the system may have to scan a lot of documents to find the matching documents. For low latency range queries, it is recommended that you use SQL++ with the necessary indexes.

                                    Parameter scanType

                                    The type of scan to execute.

                                    Parameter options

                                    Optional parameters for the scan operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method set

                                  set: (key: string) => CouchbaseSet;
                                  • Returns a CouchbaseSet permitting simple set storage in a document.

                                    Parameter key

                                    The document key the data-structure resides in.

                                  method touch

                                  touch: (
                                  key: string,
                                  expiry: number,
                                  options?: TouchOptions,
                                  callback?: NodeCallback<MutationResult>
                                  ) => Promise<MutationResult>;
                                  • Updates the expiry on an existing document.

                                    Parameter key

                                    The document key to touch.

                                    Parameter expiry

                                    The new expiry to set for the document, specified in seconds.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method unlock

                                  unlock: (
                                  key: string,
                                  cas: CasInput,
                                  options?: UnlockOptions,
                                  callback?: NodeCallback<void>
                                  ) => Promise<void>;
                                  • Unlocks a previously locked document.

                                    Parameter key

                                    The document key to unlock.

                                    Parameter cas

                                    The CAS of the document, used to validate lock ownership.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  method upsert

                                  upsert: (
                                  key: string,
                                  value: any,
                                  options?: UpsertOptions,
                                  callback?: NodeCallback<MutationResult>
                                  ) => Promise<MutationResult>;
                                  • Upserts a document to the collection. This operation succeeds whether or not the document already exists.

                                    Parameter key

                                    The document key to upsert.

                                    Parameter value

                                    The new value for the document.

                                    Parameter options

                                    Optional parameters for this operation.

                                    Parameter callback

                                    A node-style callback to be invoked after execution.

                                  class CollectionExistsError

                                  class CollectionExistsError extends CouchbaseError {}
                                  • Indicates that the referenced collection already exists, but the operation expected that it did not.

                                    Error Handling

                                  constructor

                                  constructor(cause?: Error, context?: ErrorContext);

                                    class CollectionManager

                                    class CollectionManager {}
                                    • CollectionManager allows the management of collections within a Bucket.

                                      Management

                                    method createCollection

                                    createCollection: {
                                    (
                                    collectionSpec: ICollectionSpec,
                                    options?: CreateCollectionOptions,
                                    callback?: NodeCallback<void>
                                    ): Promise<void>;
                                    (
                                    collectionName: string,
                                    scopeName: string,
                                    options?: CreateCollectionOptions,
                                    callback?: NodeCallback<void>
                                    ): Promise<void>;
                                    (
                                    collectionName: string,
                                    scopeName: string,
                                    settings?: CreateCollectionSettings,
                                    options?: CreateCollectionOptions,
                                    callback?: NodeCallback<void>
                                    ): Promise<void>;
                                    };
                                    • Creates a collection in a scope.

                                      Parameter collectionSpec

                                      Specifies the settings for the new collection.

                                      Parameter options

                                      Optional parameters for this operation.

                                      Parameter callback

                                      A node-style callback to be invoked after execution.

                                      Deprecated

                                      Use the other overload instead.

                                    • Creates a collection in a scope.

                                    • Creates a collection in a scope.

                                      Parameter collectionName

                                      The name of the collection.

                                      Parameter scopeName

                                      The name of the scope containing this collection.

                                      Parameter settings

                                      The settings to use on creating the collection.

                                      Parameter options

                                      Optional parameters for this operation.

                                      Parameter callback

                                      A node-style callback to be invoked after execution.

                                    method createScope

                                    createScope: (
                                    scopeName: string,
                                    options?: CreateScopeOptions,
                                    callback?: NodeCallback<void>
                                    ) => Promise<void>;
                                    • Creates a new scope.

                                      Parameter scopeName

                                      The name of the new scope to create.

                                      Parameter options

                                      Optional parameters for this operation.

                                      Parameter callback

                                      A node-style callback to be invoked after execution.

                                    method dropCollection

                                    dropCollection: (
                                    collectionName: string,
                                    scopeName: string,
                                    options?: DropCollectionOptions,
                                    callback?: NodeCallback<void>
                                    ) => Promise<void>;
                                    • Drops a collection from a scope.

                                      Parameter collectionName

                                      The name of the collection to drop.

                                      Parameter scopeName

                                      The name of the scope containing the collection to drop.

                                      Parameter options

                                      Optional parameters for this operation.

                                      Parameter callback

                                      A node-style callback to be invoked after execution.

                                    method dropScope

                                    dropScope: (
                                    scopeName: string,
                                    options?: DropScopeOptions,
                                    callback?: NodeCallback<void>
                                    ) => Promise<void>;
                                    • Drops a scope.

                                      Parameter scopeName

                                      The name of the scope to drop.

                                      Parameter options

                                      Optional parameters for this operation.

                                      Parameter callback

                                      A node-style callback to be invoked after execution.

                                    method getAllScopes

                                    getAllScopes: (
                                    options?: GetAllScopesOptions,
                                    callback?: NodeCallback<ScopeSpec[]>
                                    ) => Promise<ScopeSpec[]>;
                                    • Returns all configured scopes along with their collections.

                                      Parameter options

                                      Optional parameters for this operation.

                                      Parameter callback

                                      A node-style callback to be invoked after execution.

                                    method updateCollection

                                    updateCollection: (
                                    collectionName: string,
                                    scopeName: string,
                                    settings: UpdateCollectionSettings,
                                    options?: UpdateCollectionOptions,
                                    callback?: NodeCallback<void>
                                    ) => Promise<void>;
                                    • Updates a collection in a scope.

                                      Parameter collectionName

                                      The name of the collection to update.

                                      Parameter scopeName

                                      The name of the scope containing the collection.

                                      Parameter settings

                                      The settings to update on the collection.

                                      Parameter options

                                      Optional parameters for this operation.

                                      Parameter callback

                                      A node-style callback to be invoked after execution.

                                    class CollectionNotFoundError

                                    class CollectionNotFoundError extends CouchbaseError {}
                                    • Indicates that the collection being referenced does not exist.

                                      Error Handling

                                    constructor

                                    constructor(cause?: Error, context?: ErrorContext);

                                      class CollectionQueryIndexManager

                                      class CollectionQueryIndexManager {}
                                      • CollectionQueryIndexManager provides an interface for managing the query indexes on the collection.

                                        Management

                                      method buildDeferredIndexes

                                      buildDeferredIndexes: (
                                      options?: BuildQueryIndexOptions,
                                      callback?: NodeCallback<string[]>
                                      ) => Promise<string[]>;
                                      • Starts building any indexes which were previously created with deferred=true.

                                        Parameter options

                                        Optional parameters for this operation.

                                        Parameter callback

                                        A node-style callback to be invoked after execution.

                                      method createIndex

                                      createIndex: (
                                      indexName: string,
                                      keys: string[],
                                      options?: CreateQueryIndexOptions,
                                      callback?: NodeCallback<void>
                                      ) => Promise<void>;
                                      • Creates a new query index.

                                        Parameter indexName

                                        The name of the new index.

                                        Parameter keys

                                        The keys which this index should cover.

                                        Parameter options

                                        Optional parameters for this operation.

                                        Parameter callback

                                        A node-style callback to be invoked after execution.

                                      method createPrimaryIndex

                                      createPrimaryIndex: (
                                      options?: CreatePrimaryQueryIndexOptions,
                                      callback?: NodeCallback<void>
                                      ) => Promise<void>;
                                      • Creates a new primary query index.

                                        Parameter options

                                        Optional parameters for this operation.

                                        Parameter callback

                                        A node-style callback to be invoked after execution.

                                      method dropIndex

                                      dropIndex: (
                                      indexName: string,
                                      options?: DropQueryIndexOptions,
                                      callback?: NodeCallback<void>
                                      ) => Promise<void>;
                                      • Drops an existing query index.

                                        Parameter indexName

                                        The name of the index to drop.

                                        Parameter options

                                        Optional parameters for this operation.

                                        Parameter callback

                                        A node-style callback to be invoked after execution.

                                      method dropPrimaryIndex

                                      dropPrimaryIndex: (
                                      options?: DropPrimaryQueryIndexOptions,
                                      callback?: NodeCallback<void>
                                      ) => Promise<void>;
                                      • Drops an existing primary index.

                                        Parameter options

                                        Optional parameters for this operation.

                                        Parameter callback

                                        A node-style callback to be invoked after execution.

                                      method getAllIndexes

                                      getAllIndexes: (
                                      options?: GetAllQueryIndexesOptions,
                                      callback?: NodeCallback<QueryIndex[]>
                                      ) => Promise<QueryIndex[]>;
                                      • Returns a list of indexes for a specific bucket.

                                        Parameter options

                                        Optional parameters for this operation.

                                        Parameter callback

                                        A node-style callback to be invoked after execution.

                                      method watchIndexes

                                      watchIndexes: (
                                      indexNames: string[],
                                      timeout: number,
                                      options?: WatchQueryIndexOptions,
                                      callback?: NodeCallback<void>
                                      ) => Promise<void>;
                                      • Waits for a number of indexes to finish creation and be ready to use.

                                        Parameter indexNames

                                        The names of the indexes to watch.

                                        Parameter timeout

                                        The maximum time to wait for the index, expressed in milliseconds.

                                        Parameter options

                                        Optional parameters for this operation.

                                        Parameter callback

                                        A node-style callback to be invoked after execution.

                                      class CollectionSpec

                                      class CollectionSpec {}
                                      • Contains information about a collection.

                                        Management

                                      property history

                                      history?: boolean;
                                      • The history retention override setting in this collection. Only supported on Magma Buckets.

                                        See Also

                                      property maxExpiry

                                      maxExpiry: number;

                                      property name

                                      name: string;
                                      • The name of the collection.

                                      property scopeName

                                      scopeName: string;
                                      • The name of the scope this collection exists in.

                                      class CompilationFailureError

                                      class CompilationFailureError extends CouchbaseError {}
                                      • Indicates that an error occurred while compiling a query.

                                        Error Handling

                                      constructor

                                      constructor(cause?: Error, context?: ErrorContext);

                                        class ConjunctionSearchQuery

                                        class ConjunctionSearchQuery extends SearchQuery {}
                                        • Represents a conjunction search query.

                                          Full Text Search

                                        method and

                                        and: {
                                        (queries: SearchQuery[]): ConjunctionSearchQuery;
                                        (...queries: SearchQuery[]): ConjunctionSearchQuery;
                                        };
                                        • Adds additional queries to this conjunction query.

                                          Deprecated

                                          Use the multi-argument overload instead.

                                        • Adds additional queries to this conjunction query.

                                        method boost

                                        boost: (boost: number) => ConjunctionSearchQuery;

                                          class ConnectionClosedError

                                          class ConnectionClosedError extends CouchbaseError {}
                                          • Indicates that an operation was performed after a connection was closed.

                                            Error Handling

                                          constructor

                                          constructor();

                                            class CouchbaseAnalyticsEncryptionSettings

                                            class CouchbaseAnalyticsEncryptionSettings
                                            implements ICouchbaseAnalyticsEncryptionSettings {}
                                            • Includes information about an analytics remote links encryption.

                                            property certificate

                                            certificate?: Buffer;
                                            • Provides a certificate to use for connecting when encryption level is set to full. Required when encryptionLevel is set to Full.

                                            property clientCertificate

                                            clientCertificate?: Buffer;
                                            • Provides a client certificate to use for connecting when encryption level is set to full. Cannot be set if a username/password are used.

                                            property clientKey

                                            clientKey?: Buffer;
                                            • Provides a client key to use for connecting when encryption level is set to full. Cannot be set if a username/password are used.

                                            property encryptionLevel

                                            encryptionLevel: AnalyticsEncryptionLevel;
                                            • Specifies what level of encryption should be used.

                                            class CouchbaseError

                                            class CouchbaseError extends Error {}
                                            • A generic base error that all errors inherit. Exposes the cause and context of the error to enable easier debugging.

                                              Error Handling

                                            constructor

                                            constructor(message: string, cause?: Error, context?: ErrorContext);

                                              property cause

                                              cause: Error;
                                              • Specifies the underlying cause of this error, if one is available.

                                              property context

                                              context:
                                              | KeyValueErrorContext
                                              | ViewErrorContext
                                              | QueryErrorContext
                                              | SearchErrorContext
                                              | AnalyticsErrorContext
                                              | HttpErrorContext;
                                              • Specifies additional contextual information which is available for this error. Depending on the service that generated it.

                                              class CouchbaseList

                                              class CouchbaseList {}
                                              • CouchbaseList provides a simplified interface for storing lists within a Couchbase document.

                                                See Also

                                              method [Symbol.asyncIterator]

                                              [Symbol.asyncIterator]: () => AsyncIterator<any>;
                                              • Provides the ability to async-for loop this object.

                                              method forEach

                                              forEach: (
                                              rowCallback: (value: any, index: number, array: CouchbaseList) => void,
                                              callback?: NodeCallback<void>
                                              ) => Promise<void>;
                                              • Iterates each item in the list.

                                                Parameter rowCallback

                                                A callback invoked for each item in the list.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method getAll

                                              getAll: (callback?: NodeCallback<any[]>) => Promise<any[]>;
                                              • Returns the entire list of items in this list.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method getAt

                                              getAt: (index: number, callback?: NodeCallback<any>) => Promise<any>;
                                              • Retrieves the item at a specific index in the list.

                                                Parameter index

                                                The index to retrieve.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method indexOf

                                              indexOf: (value: any, callback?: NodeCallback<number>) => Promise<number>;
                                              • Returns the index of a specific value from the list.

                                                Parameter value

                                                The value to search for.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method push

                                              push: (value: any, callback?: NodeCallback<void>) => Promise<void>;
                                              • Adds a new item to the end of the list.

                                                Parameter value

                                                The value to add.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method removeAt

                                              removeAt: (index: number, callback?: NodeCallback<void>) => Promise<void>;
                                              • Removes an item at a specific index from the list.

                                                Parameter index

                                                The index to remove.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method size

                                              size: (callback?: NodeCallback<number>) => Promise<number>;
                                              • Returns the number of items in the list.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method unshift

                                              unshift: (value: any, callback?: NodeCallback<void>) => Promise<void>;
                                              • Adds a new item to the beginning of the list.

                                                Parameter value

                                                The value to add.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              class CouchbaseMap

                                              class CouchbaseMap {}
                                              • CouchbaseMap provides a simplified interface for storing a map within a Couchbase document.

                                                See Also

                                              method [Symbol.asyncIterator]

                                              [Symbol.asyncIterator]: () => AsyncIterator<[any, string]>;
                                              • Provides the ability to async-for loop this object.

                                              method exists

                                              exists: (item: string, callback?: NodeCallback<boolean>) => Promise<boolean>;
                                              • Checks whether a specific key exists in the map.

                                                Parameter item

                                                The key in the map to search for.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method forEach

                                              forEach: (
                                              rowCallback: (value: any, key: string, map: CouchbaseMap) => void,
                                              callback?: NodeCallback<void>
                                              ) => Promise<void>;
                                              • Iterates through every item in the map.

                                                Parameter rowCallback

                                                A callback invoked for each item in the list.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method get

                                              get: (item: string, callback?: NodeCallback<any>) => Promise<any>;
                                              • Fetches a specific key from the map.

                                                Parameter item

                                                The key in the map to retrieve.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method getAll

                                              getAll: (
                                              callback?: NodeCallback<{ [key: string]: any }>
                                              ) => Promise<{ [key: string]: any }>;
                                              • Returns an object representing all items in the map.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method keys

                                              keys: (callback?: NodeCallback<string[]>) => Promise<string[]>;
                                              • Returns a list of all the keys which exist in the map.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method remove

                                              remove: (item: string, callback?: NodeCallback<void>) => Promise<void>;
                                              • Removes a specific key from the map.

                                                Parameter item

                                                The key in the map to remove.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method set

                                              set: (item: string, value: any, callback?: NodeCallback<void>) => Promise<void>;
                                              • Sets a specific to the specified value in the map.

                                                Parameter item

                                                The key in the map to set.

                                                Parameter value

                                                The new value to set.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method size

                                              size: (callback?: NodeCallback<number>) => Promise<number>;
                                              • Returns the number of items that exist in the map.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method values

                                              values: (callback?: NodeCallback<any[]>) => Promise<any[]>;
                                              • Returns a list of all the values which exist in the map.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              class CouchbaseQueue

                                              class CouchbaseQueue {}
                                              • CouchbaseQueue provides a simplified interface for storing a queue within a Couchbase document.

                                                See Also

                                              method pop

                                              pop: (callback?: NodeCallback<any>) => Promise<any>;
                                              • Removes an item from the front of the queue.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method push

                                              push: (value: any, callback?: NodeCallback<void>) => Promise<void>;
                                              • Adds a new item to the back of the queue.

                                                Parameter value

                                                The value to add.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method size

                                              size: (callback?: NodeCallback<number>) => Promise<number>;
                                              • Returns the number of items in the queue.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              class CouchbaseRemoteAnalyticsLink
                                              extends AnalyticsLink
                                              implements ICouchbaseRemoteAnalyticsLink {}
                                              • Provides information about a analytics remote Couchbase link.

                                              property dataverse

                                              dataverse: string;
                                              • The dataverse that this link belongs to.

                                              property encryption

                                              encryption?: CouchbaseAnalyticsEncryptionSettings;
                                              • The encryption settings to be used for the link.

                                              property hostname

                                              hostname: string;
                                              • The hostname of the target Couchbase cluster.

                                              property linkType

                                              linkType: string;
                                              • Specifies what type of analytics link this represents.

                                              property name

                                              name: string;
                                              • The name of this link.

                                              property password

                                              password?: string;
                                              • The password to use for authentication with the remote cluster. Optional if client-certificate authentication (@see ICouchbaseAnalyticsEncryptionSettings.clientCertificate) is being used.

                                              property username

                                              username?: string;
                                              • The username to use for authentication with the remote cluster. Optional if client-certificate authentication (@see ICouchbaseAnalyticsEncryptionSettings.clientCertificate) is being used.

                                              method validate

                                              validate: () => void;
                                              • Validates the CouchbaseRemoteAnalyticsLink.

                                              class CouchbaseSet

                                              class CouchbaseSet {}
                                              • CouchbaseSet provides a simplified interface for storing a set within a Couchbase document.

                                                See Also

                                              method add

                                              add: (item: any, callback?: NodeCallback<boolean>) => Promise<boolean>;
                                              • Adds a new item to the set. Returning whether the item already existed in the set or not.

                                                Parameter item

                                                The item to add.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method contains

                                              contains: (item: any, callback?: NodeCallback<boolean>) => Promise<boolean>;
                                              • Returns whether a specific value already exists in the set.

                                                Parameter item

                                                The value to search for.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method remove

                                              remove: (item: any, callback?: NodeCallback<void>) => Promise<void>;
                                              • Removes a specific value from the set.

                                                Parameter item

                                                The value to remove.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method size

                                              size: (callback?: NodeCallback<number>) => Promise<number>;
                                              • Returns the number of elements in this set.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              method values

                                              values: (callback?: NodeCallback<any[]>) => Promise<any[]>;
                                              • Returns a list of all values in the set.

                                                Parameter callback

                                                A node-style callback to be invoked after execution.

                                              class CounterResult

                                              class CounterResult {}
                                              • Contains the results of a counter operation (binary increment/decrement).

                                                Key-Value

                                              property cas

                                              cas: Cas;
                                              • The updated CAS for the document.

                                              property token

                                              token?: MutationToken;
                                              • The token representing the mutation performed.

                                              property value

                                              value: number;
                                              • The new value of the document after the operation completed.

                                              class DatasetExistsError

                                              class DatasetExistsError extends CouchbaseError {}
                                              • Indicates that the referenced dataset already exists, but the operation expected that it did not.

                                                Error Handling

                                              constructor

                                              constructor(cause?: Error, context?: ErrorContext);

                                                class DatasetNotFoundError

                                                class DatasetNotFoundError extends CouchbaseError {}
                                                • Indicates that the referenced dataset does not exist.

                                                  Error Handling

                                                constructor

                                                constructor(cause?: Error, context?: ErrorContext);

                                                  class DataverseExistsError

                                                  class DataverseExistsError extends CouchbaseError {}
                                                  • Indicates that the referenced dataverse already exists, but the operation expected that it did not.

                                                    Error Handling

                                                  constructor

                                                  constructor(cause?: Error, context?: ErrorContext);

                                                    class DataverseNotFoundError

                                                    class DataverseNotFoundError extends CouchbaseError {}
                                                    • Indicates that the referenced dataverse does not exist.

                                                      Error Handling

                                                    constructor

                                                    constructor(cause?: Error, context?: ErrorContext);

                                                      class DateRangeSearchQuery

                                                      class DateRangeSearchQuery extends SearchQuery {}
                                                      • Represents a date-range search query.

                                                        Full Text Search

                                                      method boost

                                                      boost: (boost: number) => DateRangeSearchQuery;

                                                        method dateTimeParser

                                                        dateTimeParser: (parser: string) => DateRangeSearchQuery;

                                                          method end

                                                          end: (end: Date | string, inclusive?: boolean) => DateRangeSearchQuery;

                                                            method field

                                                            field: (field: string) => DateRangeSearchQuery;

                                                              method start

                                                              start: (start: Date | string, inclusive?: boolean) => DateRangeSearchQuery;

                                                                class DateSearchFacet

                                                                class DateSearchFacet extends SearchFacet {}
                                                                • Provides ability to request a date facet.

                                                                  Full Text Search

                                                                method addRange

                                                                addRange: (name: string, start?: Date, end?: Date) => DateSearchFacet;

                                                                  class DecodingFailureError

                                                                  class DecodingFailureError extends CouchbaseError {}
                                                                  • Indicates that there was a failure during decoding.

                                                                    Error Handling

                                                                  constructor

                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                    class DefaultTranscoder

                                                                    class DefaultTranscoder implements Transcoder {}
                                                                    • The default transcoder implements cross-sdk transcoding capabilities by taking advantage of the common flags specification to ensure compatibility. This transcoder is capable of encoding/decoding any value which is encodable to JSON, and additionally has special-case handling for Buffer objects.

                                                                      Key-Value

                                                                    method decode

                                                                    decode: (bytes: Buffer, flags: number) => any;
                                                                    • Decodes a buffer and flags tuple back to the original type of the document.

                                                                      Parameter bytes

                                                                      The bytes that were previously encoded.

                                                                      Parameter flags

                                                                      The flags associated with the data.

                                                                    method encode

                                                                    encode: (value: any) => [Buffer, number];
                                                                    • Encodes the specified value, returning a buffer and flags that are stored to the server and later used for decoding.

                                                                      Parameter value

                                                                      The value to encode.

                                                                    class DeltaInvalidError

                                                                    class DeltaInvalidError extends CouchbaseError {}
                                                                    • Indicates that the delta specified is invalid.

                                                                      Error Handling

                                                                    constructor

                                                                    constructor(cause?: Error, context?: ErrorContext);

                                                                      class DesignDocument

                                                                      class DesignDocument {}
                                                                      • Contains information about a design document.

                                                                        Management

                                                                      constructor

                                                                      constructor(data: {
                                                                      name: string;
                                                                      views?: { [viewName: string]: DesignDocumentView };
                                                                      namespace?: DesignDocumentNamespace;
                                                                      rev?: string;
                                                                      });

                                                                        constructor

                                                                        constructor(name: string, views: { [viewName: string]: DesignDocumentView });
                                                                        • Deprecated

                                                                        property name

                                                                        name: string;
                                                                        • The name of the design document.

                                                                        property namespace

                                                                        namespace: DesignDocumentNamespace;
                                                                        • The namespace for this design document.

                                                                        property rev

                                                                        rev: string;
                                                                        • The revision of the design document.

                                                                        property View

                                                                        static readonly View: any;

                                                                        property views

                                                                        views: { [viewName: string]: DesignDocumentView };
                                                                        • A map of the views that exist in this design document.

                                                                        class DesignDocumentNotFoundError

                                                                        class DesignDocumentNotFoundError extends CouchbaseError {}
                                                                        • Indicates that the referenced design document does not exist.

                                                                          Error Handling

                                                                        constructor

                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                          class DesignDocumentView

                                                                          class DesignDocumentView {}
                                                                          • Contains information about a view in a design document.

                                                                            Management

                                                                          constructor

                                                                          constructor(data: { map?: string; reduce?: string });

                                                                            constructor

                                                                            constructor(map?: string, reduce?: string);
                                                                            • Deprecated

                                                                            property map

                                                                            map: string;
                                                                            • The mapping function to use for this view.

                                                                            property reduce

                                                                            reduce: string;
                                                                            • The reduction function to use for this view.

                                                                            class DiagnosticsEndpoint

                                                                            class DiagnosticsEndpoint {}
                                                                            • DiagnosticsEndpoint represents a single endpoint in a diagnostics result.

                                                                              Diagnostics

                                                                            property bucket

                                                                            bucket?: string;
                                                                            • The name of the bucket this endpoint is connected to.

                                                                            property details

                                                                            details?: any;
                                                                            • Various additional details about the endpoint.

                                                                            property id

                                                                            id: string;
                                                                            • The unique identifier for this endpoint.

                                                                            property lastActivity

                                                                            lastActivity: number;
                                                                            • The time in milliseconds since the last activity.

                                                                            property local

                                                                            local: string;
                                                                            • The local address of this endpoint.

                                                                            property remote

                                                                            remote: string;
                                                                            • The remote address of this endpoint.

                                                                            property state

                                                                            state: EndpointState;
                                                                            • The current state of this endpoint.

                                                                            property type

                                                                            type: ServiceType;
                                                                            • The type of service this entry represents.

                                                                            class DiagnosticsResult

                                                                            class DiagnosticsResult {}
                                                                            • DiagnosticsResult represents the output of a operation result.

                                                                              Diagnostics

                                                                            property id

                                                                            id: string;
                                                                            • The unique identifier for this report.

                                                                            property sdk

                                                                            sdk: string;
                                                                            • The name of the SDK which generated this report.

                                                                            property services

                                                                            services: { [serviceType: string]: DiagnosticsEndpoint[] };
                                                                            • A list of service endpoints and their diagnostic status.

                                                                            property version

                                                                            version: number;
                                                                            • The version number of this report.

                                                                            method toJSON

                                                                            toJSON: () => JsonDiagnosticsReport;
                                                                            • Returns a JSON formatted diagnostics report.

                                                                            class DisjunctionSearchQuery

                                                                            class DisjunctionSearchQuery extends SearchQuery {}
                                                                            • Represents a disjunction search query.

                                                                              Full Text Search

                                                                            method boost

                                                                            boost: (boost: number) => DisjunctionSearchQuery;

                                                                              method or

                                                                              or: {
                                                                              (queries: SearchQuery[]): DisjunctionSearchQuery;
                                                                              (...queries: SearchQuery[]): DisjunctionSearchQuery;
                                                                              };
                                                                              • Adds additional queries to this disjunction query.

                                                                                Deprecated

                                                                                Use the multi-argument overload instead.

                                                                              • Adds additional queries to this disjunction query.

                                                                              class DmlFailureError

                                                                              class DmlFailureError extends CouchbaseError {}
                                                                              • Indicates that a generic DML error occurred with a query.

                                                                                Error Handling

                                                                              constructor

                                                                              constructor(cause?: Error, context?: ErrorContext);

                                                                                class DocIdSearchQuery

                                                                                class DocIdSearchQuery extends SearchQuery {}
                                                                                • Represents a document-id search query.

                                                                                  Full Text Search

                                                                                method addDocIds

                                                                                addDocIds: {
                                                                                (ids: string[]): DocIdSearchQuery;
                                                                                (...ids: string[]): DocIdSearchQuery;
                                                                                };
                                                                                • Adds additional document-id's to this query.

                                                                                  Deprecated

                                                                                  Use the multi-argument overload instead.

                                                                                • Adds additional document-id's to this query.

                                                                                method boost

                                                                                boost: (boost: number) => DocIdSearchQuery;

                                                                                  method field

                                                                                  field: (field: string) => DocIdSearchQuery;

                                                                                    class DocumentExistsError

                                                                                    class DocumentExistsError extends CouchbaseError {}
                                                                                    • Indicates that the referenced document exists already, but the operation was not expecting it to exist.

                                                                                      Error Handling

                                                                                    constructor

                                                                                    constructor(cause?: Error, context?: ErrorContext);

                                                                                      class DocumentId

                                                                                      class DocumentId {}
                                                                                      • Represents the path to a document.

                                                                                        Transactions

                                                                                      constructor

                                                                                      constructor();

                                                                                        property bucket

                                                                                        bucket: string;
                                                                                        • The name of the bucket containing the document.

                                                                                        property collection

                                                                                        collection: string;
                                                                                        • The name of the collection containing the document.

                                                                                        property key

                                                                                        key: string;
                                                                                        • The key of the docuemnt.

                                                                                        property scope

                                                                                        scope: string;
                                                                                        • The name of the scope containing the document.

                                                                                        class DocumentLockedError

                                                                                        class DocumentLockedError extends CouchbaseError {}
                                                                                        • Indicates that the referenced document could not be used as it is currently locked, likely by another actor in the system.

                                                                                          Error Handling

                                                                                        constructor

                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                          class DocumentNotFoundError

                                                                                          class DocumentNotFoundError extends CouchbaseError {}
                                                                                          • Indicates that the referenced document does not exist.

                                                                                            Error Handling

                                                                                          constructor

                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                            class DocumentNotJsonError

                                                                                            class DocumentNotJsonError extends CouchbaseError {}
                                                                                            • Indicates that an operation expecting JSON was performed against a document which is not JSON.

                                                                                              Error Handling

                                                                                            constructor

                                                                                            constructor(cause?: Error, context?: ErrorContext);

                                                                                              class DocumentNotLockedError

                                                                                              class DocumentNotLockedError extends CouchbaseError {}
                                                                                              • Indicates that the referenced document is not locked. Generally raised when an unlock operation is performed.

                                                                                                Error Handling

                                                                                              constructor

                                                                                              constructor(cause?: Error, context?: ErrorContext);

                                                                                                class DocumentUnretrievableError

                                                                                                class DocumentUnretrievableError extends CouchbaseError {}
                                                                                                • Indicates that the referenced document could not be retrieved.

                                                                                                  Error Handling

                                                                                                constructor

                                                                                                constructor(cause?: Error, context?: ErrorContext);

                                                                                                  class DurabilityAmbiguousError

                                                                                                  class DurabilityAmbiguousError extends CouchbaseError {}
                                                                                                  • Indicates that the durable operation that was performed has failed ambiguously and may or may not have completed, or may complete in the future.

                                                                                                    Error Handling

                                                                                                  constructor

                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                    class DurabilityImpossibleError

                                                                                                    class DurabilityImpossibleError extends CouchbaseError {}
                                                                                                    • Indicates that a durability level which is impossible to achieve was specified. This can occur when you try to use Majority but there is less than the majority of nodes available.

                                                                                                      Error Handling

                                                                                                    constructor

                                                                                                    constructor(cause?: Error, context?: ErrorContext);

                                                                                                      class DurabilityLevelNotAvailableError

                                                                                                      class DurabilityLevelNotAvailableError extends CouchbaseError {}
                                                                                                      • Indicates that a durability level which is not available was specified.

                                                                                                        Error Handling

                                                                                                      constructor

                                                                                                      constructor(cause?: Error, context?: ErrorContext);

                                                                                                        class DurableWriteInProgressError

                                                                                                        class DurableWriteInProgressError extends CouchbaseError {}
                                                                                                        • Indicates that a write was failed as an existing durable write against that key is already in progress.

                                                                                                          Error Handling

                                                                                                        constructor

                                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                                          class DurableWriteReCommitInProgressError

                                                                                                          class DurableWriteReCommitInProgressError extends CouchbaseError {}
                                                                                                          • Indicates that a write was failed as the server is currently reconstructing it's durable data following a failover.

                                                                                                            Error Handling

                                                                                                          constructor

                                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                                            class EncodingFailureError

                                                                                                            class EncodingFailureError extends CouchbaseError {}
                                                                                                            • Indicates that there was a failure during encoding.

                                                                                                              Error Handling

                                                                                                            constructor

                                                                                                            constructor(cause?: Error, context?: ErrorContext);

                                                                                                              class ErrorContext

                                                                                                              class ErrorContext {}
                                                                                                              • Generic base class for all known error context types.

                                                                                                                Error Handling

                                                                                                              class EventingFunction

                                                                                                              class EventingFunction {}
                                                                                                              • Describes an eventing function.

                                                                                                                Management

                                                                                                              constructor

                                                                                                              constructor(v: EventingFunction);

                                                                                                                property bucketBindings

                                                                                                                bucketBindings: EventingFunctionBucketBinding[];
                                                                                                                • The buckets to bind to the function.

                                                                                                                property code

                                                                                                                code: string;
                                                                                                                • The code for this eventing function.

                                                                                                                property constantBindings

                                                                                                                constantBindings: EventingFunctionConstantBinding[];
                                                                                                                • The constants to bind to the function.

                                                                                                                property enforceSchema

                                                                                                                enforceSchema?: boolean;
                                                                                                                • Whether to enable stricter validation of settings and configuration.

                                                                                                                property functionInstanceId

                                                                                                                functionInstanceId?: string;
                                                                                                                • The unique id for the deployment of the handler.

                                                                                                                property handlerUuid

                                                                                                                handlerUuid?: number;
                                                                                                                • The unique ID for this eventing function.

                                                                                                                property metadataKeyspace

                                                                                                                metadataKeyspace: EventingFunctionKeyspace;
                                                                                                                • The keyspace to store the functions metadata.

                                                                                                                property name

                                                                                                                name: string;
                                                                                                                • The name of the eventing function.

                                                                                                                property settings

                                                                                                                settings: EventingFunctionSettings;
                                                                                                                • The settings for this function.

                                                                                                                property sourceKeyspace

                                                                                                                sourceKeyspace: EventingFunctionKeyspace;
                                                                                                                • The keyspace that the function should operate on.

                                                                                                                property urlBindings

                                                                                                                urlBindings: EventingFunctionUrlBinding[];
                                                                                                                • The URLs to bind to the function.

                                                                                                                property version

                                                                                                                version?: string;
                                                                                                                • The authoring version of this eventing function.

                                                                                                                class EventingFunctionBucketBinding

                                                                                                                class EventingFunctionBucketBinding {}
                                                                                                                • Specifies a bucket binding for an eventing function.

                                                                                                                  Management

                                                                                                                constructor

                                                                                                                constructor(v: EventingFunctionBucketBinding);

                                                                                                                  property access

                                                                                                                  access: EventingFunctionBucketAccess;
                                                                                                                  • The level of access configured for this binding.

                                                                                                                  property alias

                                                                                                                  alias: string;
                                                                                                                  • The alias to use for referring to this binding.

                                                                                                                  property name

                                                                                                                  name: EventingFunctionKeyspace;
                                                                                                                  • The keyspace that this binding refers to.

                                                                                                                  class EventingFunctionCompilationFailureError

                                                                                                                  class EventingFunctionCompilationFailureError extends CouchbaseError {}
                                                                                                                  • Indicates that the eventing function was not able to be compiled.

                                                                                                                    Error Handling

                                                                                                                  constructor

                                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                                    class EventingFunctionConstantBinding

                                                                                                                    class EventingFunctionConstantBinding {}
                                                                                                                    • Specifies a constant binding for an eventing function.

                                                                                                                      Management

                                                                                                                    constructor

                                                                                                                    constructor(v: EventingFunctionConstantBinding);

                                                                                                                      property alias

                                                                                                                      alias: string;
                                                                                                                      • The alias to use for referring to this binding.

                                                                                                                      property literal

                                                                                                                      literal: string;
                                                                                                                      • The literal value for this binding.

                                                                                                                      class EventingFunctionDeployedError

                                                                                                                      class EventingFunctionDeployedError extends CouchbaseError {}
                                                                                                                      • Indicates that an eventing function is deployed but the operation expected that it was not.

                                                                                                                        Error Handling

                                                                                                                      constructor

                                                                                                                      constructor(cause?: Error, context?: ErrorContext);

                                                                                                                        class EventingFunctionIdenticalKeyspaceError

                                                                                                                        class EventingFunctionIdenticalKeyspaceError extends CouchbaseError {}
                                                                                                                        • Indicates that the source and metadata keyspaces both referenced the same place for an eventing function.

                                                                                                                          Error Handling

                                                                                                                        constructor

                                                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                                                          class EventingFunctionKeyspace

                                                                                                                          class EventingFunctionKeyspace {}
                                                                                                                          • Specifies the bucket/scope/collection used by an eventing function.

                                                                                                                            Management

                                                                                                                          constructor

                                                                                                                          constructor(v: EventingFunctionKeyspace);

                                                                                                                            property bucket

                                                                                                                            bucket: string;
                                                                                                                            • The bucket to use.

                                                                                                                            property collection

                                                                                                                            collection?: string;
                                                                                                                            • The collection to use.

                                                                                                                            property scope

                                                                                                                            scope?: string;
                                                                                                                            • The scope to use.

                                                                                                                            class EventingFunctionManager

                                                                                                                            class EventingFunctionManager {}
                                                                                                                            • EventingFunctionManager provides an interface for managing the eventing functions on the cluster. Uncommitted: This API is subject to change in the future.

                                                                                                                              Management

                                                                                                                            method deployFunction

                                                                                                                            deployFunction: (
                                                                                                                            name: string,
                                                                                                                            options?: DeployFunctionOptions,
                                                                                                                            callback?: NodeCallback<void>
                                                                                                                            ) => Promise<void>;
                                                                                                                            • Deploys an eventing function.

                                                                                                                              Parameter name

                                                                                                                              The name of the eventing function to deploy.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            method dropFunction

                                                                                                                            dropFunction: (
                                                                                                                            name: string,
                                                                                                                            options?: DropFunctionOptions,
                                                                                                                            callback?: NodeCallback<void>
                                                                                                                            ) => Promise<void>;
                                                                                                                            • Deletes an eventing function.

                                                                                                                              Parameter name

                                                                                                                              The name of the eventing function to delete.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            method functionsStatus

                                                                                                                            functionsStatus: (
                                                                                                                            options?: FunctionsStatusOptions,
                                                                                                                            callback?: NodeCallback<EventingState>
                                                                                                                            ) => Promise<EventingState>;
                                                                                                                            • Fetches the status of all eventing functions.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            method getAllFunctions

                                                                                                                            getAllFunctions: (
                                                                                                                            options?: GetAllFunctionsOptions,
                                                                                                                            callback?: NodeCallback<EventingFunction[]>
                                                                                                                            ) => Promise<EventingFunction[]>;
                                                                                                                            • Fetches all eventing functions.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            method getFunction

                                                                                                                            getFunction: (
                                                                                                                            name: string,
                                                                                                                            options?: GetFunctionOptions,
                                                                                                                            callback?: NodeCallback<EventingFunction>
                                                                                                                            ) => Promise<EventingFunction>;
                                                                                                                            • Fetches a specific eventing function.

                                                                                                                              Parameter name

                                                                                                                              The name of the eventing function to fetch.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            method pauseFunction

                                                                                                                            pauseFunction: (
                                                                                                                            name: string,
                                                                                                                            options?: PauseFunctionOptions,
                                                                                                                            callback?: NodeCallback<void>
                                                                                                                            ) => Promise<void>;
                                                                                                                            • Pauses an eventing function.

                                                                                                                              Parameter name

                                                                                                                              The name of the eventing function to pause.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            method resumeFunction

                                                                                                                            resumeFunction: (
                                                                                                                            name: string,
                                                                                                                            options?: ResumeFunctionOptions,
                                                                                                                            callback?: NodeCallback<void>
                                                                                                                            ) => Promise<void>;
                                                                                                                            • Resumes an eventing function.

                                                                                                                              Parameter name

                                                                                                                              The name of the eventing function to resume.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            method undeployFunction

                                                                                                                            undeployFunction: (
                                                                                                                            name: string,
                                                                                                                            options?: DeployFunctionOptions,
                                                                                                                            callback?: NodeCallback<void>
                                                                                                                            ) => Promise<void>;
                                                                                                                            • Undeploys an eventing function.

                                                                                                                              Parameter name

                                                                                                                              The name of the eventing function to undeploy.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            method upsertFunction

                                                                                                                            upsertFunction: (
                                                                                                                            functionDefinition: EventingFunction,
                                                                                                                            options?: UpsertFunctionOptions,
                                                                                                                            callback?: NodeCallback<void>
                                                                                                                            ) => Promise<void>;
                                                                                                                            • Creates or updates an eventing function.

                                                                                                                              Parameter functionDefinition

                                                                                                                              The description of the eventing function to upsert.

                                                                                                                              Parameter options

                                                                                                                              Optional parameters for this operation.

                                                                                                                              Parameter callback

                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                            class EventingFunctionNotBootstrappedError

                                                                                                                            class EventingFunctionNotBootstrappedError extends CouchbaseError {}
                                                                                                                            • Indicates that an eventing function was deployed but has not yet fully completed the bootstrapping process.

                                                                                                                              Error Handling

                                                                                                                            constructor

                                                                                                                            constructor(cause?: Error, context?: ErrorContext);

                                                                                                                              class EventingFunctionNotDeployedError

                                                                                                                              class EventingFunctionNotDeployedError extends CouchbaseError {}
                                                                                                                              • Indicates that the referenced eventing function was not deployed but was expected to have been.

                                                                                                                                Error Handling

                                                                                                                              constructor

                                                                                                                              constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                class EventingFunctionNotFoundError

                                                                                                                                class EventingFunctionNotFoundError extends CouchbaseError {}
                                                                                                                                • Indicates that the referenced eventing function does not exist.

                                                                                                                                  Error Handling

                                                                                                                                constructor

                                                                                                                                constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                  class EventingFunctionPausedError

                                                                                                                                  class EventingFunctionPausedError extends CouchbaseError {}
                                                                                                                                  • Indicates that an eventing function is paused but the operation expected that it was not.

                                                                                                                                    Error Handling

                                                                                                                                  constructor

                                                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                    class EventingFunctionSettings

                                                                                                                                    class EventingFunctionSettings {}
                                                                                                                                    • Specifies a number of options which can be used when updating or creating a eventing function.

                                                                                                                                      Management

                                                                                                                                    constructor

                                                                                                                                    constructor(v: EventingFunctionSettings);

                                                                                                                                      property appLogDir

                                                                                                                                      appLogDir?: string;
                                                                                                                                      • The directory to write content of log() message files.

                                                                                                                                      property appLogMaxFiles

                                                                                                                                      appLogMaxFiles?: number;
                                                                                                                                      • The number of log() message files to retain when rotating.

                                                                                                                                      property appLogMaxSize

                                                                                                                                      appLogMaxSize?: number;
                                                                                                                                      • The size in bytes of the log file when the file should be rotated.

                                                                                                                                      property bucketCacheAge

                                                                                                                                      bucketCacheAge?: number;
                                                                                                                                      • The time in milliseconds after which a cached bucket object is considered stale.

                                                                                                                                      property bucketCacheSize

                                                                                                                                      bucketCacheSize?: number;
                                                                                                                                      • The maximum size in bytes the bucket cache can grow to.

                                                                                                                                      property checkpointInterval

                                                                                                                                      checkpointInterval?: number;
                                                                                                                                      • The number of seconds before writing a progress checkpoint.

                                                                                                                                      property cppWorkerThreadCount

                                                                                                                                      cppWorkerThreadCount?: number;
                                                                                                                                      • The number of worker threads to use for the function.

                                                                                                                                      property curlMaxAllowedRespSize

                                                                                                                                      curlMaxAllowedRespSize?: number;
                                                                                                                                      • The maximum allowable curl call response in 'MegaBytes'. Setting the value to 0 lifts the upper limit off. This parameters affects v8 engine stability since it defines the maximum amount of heap space acquired by a curl call.

                                                                                                                                      property dcpStreamBoundary

                                                                                                                                      dcpStreamBoundary?: EventingFunctionDcpBoundary;
                                                                                                                                      • The DCP stream boundary to use.

                                                                                                                                      property deploymentStatus

                                                                                                                                      deploymentStatus?: EventingFunctionDeploymentStatus;
                                                                                                                                      • The current deployment status of the function.

                                                                                                                                      property description

                                                                                                                                      description?: string;
                                                                                                                                      • A description of this eventing function.

                                                                                                                                      property enableAppLogRotation

                                                                                                                                      enableAppLogRotation?: boolean;
                                                                                                                                      • Whether to enable rotating this handlers log() message files.

                                                                                                                                      property executionTimeout

                                                                                                                                      executionTimeout?: number;
                                                                                                                                      • The maximum period of time the function can execute on a document before timing out.

                                                                                                                                      property handlerFooters

                                                                                                                                      handlerFooters?: string[];
                                                                                                                                      • The code to automatically append to bottom of handler code.

                                                                                                                                      property handlerHeaders

                                                                                                                                      handlerHeaders?: string[];
                                                                                                                                      • The code to automatically prepend to top of handler code.

                                                                                                                                      property languageCompatibility

                                                                                                                                      languageCompatibility?: EventingFunctionLanguageCompatibility;
                                                                                                                                      • The active compatibility mode for the function.

                                                                                                                                      property lcbInstCapacity

                                                                                                                                      lcbInstCapacity?: number;
                                                                                                                                      • The maximum number of internal clients that the function should maintain for KV operations.

                                                                                                                                      property lcbRetryCount

                                                                                                                                      lcbRetryCount?: number;
                                                                                                                                      • The maximum number of times to retry a KV operation before failing the function.

                                                                                                                                      property lcbTimeout

                                                                                                                                      lcbTimeout?: number;
                                                                                                                                      • The maximum period of time a KV operation within the function can operate before timing out.

                                                                                                                                      property logLevel

                                                                                                                                      logLevel?: EventingFunctionLogLevel;
                                                                                                                                      • The level of logging that should be captured for the function.

                                                                                                                                      property numTimerPartitions

                                                                                                                                      numTimerPartitions?: number;
                                                                                                                                      • The number of partitions that should be used for timer tracking.

                                                                                                                                      property processingStatus

                                                                                                                                      processingStatus?: EventingFunctionProcessingStatus;
                                                                                                                                      • The current processing status of the function.

                                                                                                                                      property queryConsistency

                                                                                                                                      queryConsistency?: QueryScanConsistency;
                                                                                                                                      • The level of consistency to use when performing queries in the function.

                                                                                                                                      property queryPrepareAll

                                                                                                                                      queryPrepareAll?: boolean;
                                                                                                                                      • Whether to automatically prepare all query statements in the handler.

                                                                                                                                      property sockBatchSize

                                                                                                                                      sockBatchSize?: number;
                                                                                                                                      • The batch size for messages from producer to consumer.

                                                                                                                                      property tickDuration

                                                                                                                                      tickDuration?: number;
                                                                                                                                      • The duration to log stats from this handler, in milliseconds.

                                                                                                                                      property timerContextSize

                                                                                                                                      timerContextSize?: number;
                                                                                                                                      • The size limit of timer context object.

                                                                                                                                      property userPrefix

                                                                                                                                      userPrefix?: string;
                                                                                                                                      • The key prefix for all data stored in metadata by this handler.

                                                                                                                                      property workerCount

                                                                                                                                      workerCount?: number;
                                                                                                                                      • The number of worker processes handler utilizes on each eventing node.

                                                                                                                                      class EventingFunctionState

                                                                                                                                      class EventingFunctionState {}
                                                                                                                                      • Describes the current state of an eventing function.

                                                                                                                                        Management

                                                                                                                                      constructor

                                                                                                                                      constructor(v: EventingFunctionState);

                                                                                                                                        property deploymentStatus

                                                                                                                                        deploymentStatus: EventingFunctionDeploymentStatus;
                                                                                                                                        • The current deployment status of this eventing function.

                                                                                                                                        property name

                                                                                                                                        name: string;
                                                                                                                                        • The name of the eventing function.

                                                                                                                                        property numBootstrappingNodes

                                                                                                                                        numBootstrappingNodes: number;
                                                                                                                                        • The number of nodes where this eventing function is bootstrapping.

                                                                                                                                        property numDeployedNodes

                                                                                                                                        numDeployedNodes: number;
                                                                                                                                        • The number of nodes where this eventing function is deployed.

                                                                                                                                        property processingStatus

                                                                                                                                        processingStatus: EventingFunctionProcessingStatus;
                                                                                                                                        • The current processing status of this eventing function.

                                                                                                                                        property status

                                                                                                                                        status: EventingFunctionStatus;
                                                                                                                                        • The current overall state of this eventing function.

                                                                                                                                        class EventingFunctionUrlAuthBasic

                                                                                                                                        class EventingFunctionUrlAuthBasic implements EventingFunctionUrlAuth {}
                                                                                                                                        • Specifies that Basic authentication should be used for the URL.

                                                                                                                                          Management

                                                                                                                                        constructor

                                                                                                                                        constructor(v: Omit<EventingFunctionUrlAuthBasic, 'method'>);

                                                                                                                                          property method

                                                                                                                                          method: EventingFunctionUrlAuthMethod;
                                                                                                                                          • Sets the auth method to Basic.

                                                                                                                                          property password

                                                                                                                                          password: string;
                                                                                                                                          • Specifies the password to use for authentication.

                                                                                                                                          property username

                                                                                                                                          username: string;
                                                                                                                                          • Specifies the username to use for authentication.

                                                                                                                                          class EventingFunctionUrlAuthBearer

                                                                                                                                          class EventingFunctionUrlAuthBearer implements EventingFunctionUrlAuth {}
                                                                                                                                          • Specifies that Bearer authentication should be used for the URL.

                                                                                                                                            Management

                                                                                                                                          constructor

                                                                                                                                          constructor(v: Omit<EventingFunctionUrlAuthBearer, 'method'>);

                                                                                                                                            property key

                                                                                                                                            key: string;
                                                                                                                                            • Specifies the bearer token to use.

                                                                                                                                            property method

                                                                                                                                            method: EventingFunctionUrlAuthMethod;
                                                                                                                                            • Sets the auth method to Bearer.

                                                                                                                                            class EventingFunctionUrlAuthDigest

                                                                                                                                            class EventingFunctionUrlAuthDigest implements EventingFunctionUrlAuth {}
                                                                                                                                            • Specifies that Digest authentication should be used for the URL.

                                                                                                                                              Management

                                                                                                                                            constructor

                                                                                                                                            constructor(v: Omit<EventingFunctionUrlAuthDigest, 'method'>);

                                                                                                                                              property method

                                                                                                                                              method: EventingFunctionUrlAuthMethod;
                                                                                                                                              • Sets the auth method to Digest.

                                                                                                                                              property password

                                                                                                                                              password: string;
                                                                                                                                              • Specifies the password to use for authentication.

                                                                                                                                              property username

                                                                                                                                              username: string;
                                                                                                                                              • Specifies the username to use for authentication.

                                                                                                                                              class EventingFunctionUrlBinding

                                                                                                                                              class EventingFunctionUrlBinding {}
                                                                                                                                              • Specifies a url binding for an eventing function.

                                                                                                                                                Management

                                                                                                                                              constructor

                                                                                                                                              constructor(v: EventingFunctionUrlBinding);

                                                                                                                                                property alias

                                                                                                                                                alias: string;
                                                                                                                                                • The alias to use for referring to this binding.

                                                                                                                                                property allowCookies

                                                                                                                                                allowCookies: boolean;
                                                                                                                                                • Whether or not cookies should be allowed.

                                                                                                                                                property auth

                                                                                                                                                auth?: EventingFunctionUrlAuth;
                                                                                                                                                • The authentication that should be used.

                                                                                                                                                property hostname

                                                                                                                                                hostname: string;
                                                                                                                                                • The hostname this url binding should refer to.

                                                                                                                                                property validateSslCertificate

                                                                                                                                                validateSslCertificate: boolean;
                                                                                                                                                • Whether the SSL certificate should be validated.

                                                                                                                                                class EventingState

                                                                                                                                                class EventingState {}
                                                                                                                                                • Describes the current state of all eventing function.

                                                                                                                                                  Management

                                                                                                                                                constructor

                                                                                                                                                constructor(v: EventingState);

                                                                                                                                                  property functions

                                                                                                                                                  functions: EventingFunctionState[];
                                                                                                                                                  • The states of all registered eventing functions.

                                                                                                                                                  property numEventingNodes

                                                                                                                                                  numEventingNodes: number;
                                                                                                                                                  • The number of eventing nodes that are currently active.

                                                                                                                                                  class ExistsResult

                                                                                                                                                  class ExistsResult {}
                                                                                                                                                  • Contains the results of an exists operation.

                                                                                                                                                    Key-Value

                                                                                                                                                  property cas

                                                                                                                                                  cas: Cas;
                                                                                                                                                  • The CAS of the document.

                                                                                                                                                  property exists

                                                                                                                                                  exists: boolean;
                                                                                                                                                  • Indicates whether the document existed or not.

                                                                                                                                                  class FeatureNotAvailableError

                                                                                                                                                  class FeatureNotAvailableError extends CouchbaseError {}
                                                                                                                                                  • Indicates a feature which is not available was used. This primarily can occur if you attempt to perform a query when no query services are enabled on the cluster, or if a newer server feature which is not available in the connected server version is used.

                                                                                                                                                    Error Handling

                                                                                                                                                  constructor

                                                                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                    class FieldSearchSort

                                                                                                                                                    class FieldSearchSort extends SearchSort {}
                                                                                                                                                    • Provides sorting for a search query by a specified field.

                                                                                                                                                      Full Text Search

                                                                                                                                                    method descending

                                                                                                                                                    descending: (descending: boolean) => FieldSearchSort;

                                                                                                                                                      method missing

                                                                                                                                                      missing: (missing: boolean) => FieldSearchSort;

                                                                                                                                                        method mode

                                                                                                                                                        mode: (mode: string) => FieldSearchSort;

                                                                                                                                                          method type

                                                                                                                                                          type: (type: string) => FieldSearchSort;

                                                                                                                                                            class GeoBoundingBoxSearchQuery

                                                                                                                                                            class GeoBoundingBoxSearchQuery extends SearchQuery {}
                                                                                                                                                            • Represents a geo-bounding-box search query.

                                                                                                                                                              Full Text Search

                                                                                                                                                            method boost

                                                                                                                                                            boost: (boost: number) => GeoBoundingBoxSearchQuery;

                                                                                                                                                              method field

                                                                                                                                                              field: (field: string) => GeoBoundingBoxSearchQuery;

                                                                                                                                                                class GeoDistanceSearchQuery

                                                                                                                                                                class GeoDistanceSearchQuery extends SearchQuery {}
                                                                                                                                                                • Represents a geo-distance search query.

                                                                                                                                                                  Full Text Search

                                                                                                                                                                method boost

                                                                                                                                                                boost: (boost: number) => GeoDistanceSearchQuery;

                                                                                                                                                                  method field

                                                                                                                                                                  field: (field: string) => GeoDistanceSearchQuery;

                                                                                                                                                                    class GeoDistanceSearchSort

                                                                                                                                                                    class GeoDistanceSearchSort extends SearchSort {}
                                                                                                                                                                    • Provides sorting for a search query by geographic distance from a point.

                                                                                                                                                                      Full Text Search

                                                                                                                                                                    method descending

                                                                                                                                                                    descending: (descending: boolean) => GeoDistanceSearchSort;

                                                                                                                                                                      method unit

                                                                                                                                                                      unit: (unit: string) => GeoDistanceSearchSort;

                                                                                                                                                                        class GeoPolygonSearchQuery

                                                                                                                                                                        class GeoPolygonSearchQuery extends SearchQuery {}
                                                                                                                                                                        • Represents a geo-polygon search query.

                                                                                                                                                                          Full Text Search

                                                                                                                                                                        method boost

                                                                                                                                                                        boost: (boost: number) => GeoPolygonSearchQuery;

                                                                                                                                                                          method field

                                                                                                                                                                          field: (field: string) => GeoPolygonSearchQuery;

                                                                                                                                                                            class GetReplicaResult

                                                                                                                                                                            class GetReplicaResult {}
                                                                                                                                                                            • Contains the results of a get from replica operation.

                                                                                                                                                                              Key-Value

                                                                                                                                                                            property cas

                                                                                                                                                                            cas: Cas;
                                                                                                                                                                            • The cas of the document, as it is known by the replica.

                                                                                                                                                                            property content

                                                                                                                                                                            content: any;
                                                                                                                                                                            • The content of the document, as it existed on the replica.

                                                                                                                                                                            property isReplica

                                                                                                                                                                            isReplica: boolean;
                                                                                                                                                                            • Indicates whether this result came from a replica or the primary.

                                                                                                                                                                            class GetResult

                                                                                                                                                                            class GetResult {}
                                                                                                                                                                            • Contains the results of a Get operation.

                                                                                                                                                                              Key-Value

                                                                                                                                                                            property cas

                                                                                                                                                                            cas: Cas;
                                                                                                                                                                            • The CAS of the document.

                                                                                                                                                                            property content

                                                                                                                                                                            content: any;
                                                                                                                                                                            • The content of the document.

                                                                                                                                                                            property expiry

                                                                                                                                                                            readonly expiry: number;

                                                                                                                                                                            property expiryTime

                                                                                                                                                                            expiryTime?: number;

                                                                                                                                                                            property value

                                                                                                                                                                            value: any;
                                                                                                                                                                            • BUG(JSCBC-784): This previously held the content of the document.

                                                                                                                                                                              Deprecated

                                                                                                                                                                              Use GetResult.content instead.

                                                                                                                                                                            class Group

                                                                                                                                                                            class Group {}
                                                                                                                                                                            • Contains information about a group.

                                                                                                                                                                              Management

                                                                                                                                                                            property description

                                                                                                                                                                            description: string;
                                                                                                                                                                            • The description for the group.

                                                                                                                                                                            property ldapGroupReference

                                                                                                                                                                            ldapGroupReference: string;
                                                                                                                                                                            • The LDAP group that this group is associated with.

                                                                                                                                                                            property name

                                                                                                                                                                            name: string;
                                                                                                                                                                            • The name of the group.

                                                                                                                                                                            property roles

                                                                                                                                                                            roles: Role[];
                                                                                                                                                                            • The roles which are associated with this group.

                                                                                                                                                                            class GroupNotFoundError

                                                                                                                                                                            class GroupNotFoundError extends CouchbaseError {}
                                                                                                                                                                            • Indicates that the referenced group does not exist.

                                                                                                                                                                              Error Handling

                                                                                                                                                                            constructor

                                                                                                                                                                            constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                              class HttpErrorContext

                                                                                                                                                                              class HttpErrorContext extends ErrorContext {}
                                                                                                                                                                              • The error context information for a http operation.

                                                                                                                                                                                Error Handling

                                                                                                                                                                              property method

                                                                                                                                                                              method: string;
                                                                                                                                                                              • The HTTP method of the request that was performed.

                                                                                                                                                                              property request_path

                                                                                                                                                                              request_path: string;
                                                                                                                                                                              • The request path for the request that was being performed.

                                                                                                                                                                              property response_body

                                                                                                                                                                              response_body: string;
                                                                                                                                                                              • The http response body which was received.

                                                                                                                                                                              property response_code

                                                                                                                                                                              response_code: number;
                                                                                                                                                                              • The http response status code which was received.

                                                                                                                                                                              class IdSearchSort

                                                                                                                                                                              class IdSearchSort extends SearchSort {}
                                                                                                                                                                              • Provides sorting for a search query by document id.

                                                                                                                                                                                Full Text Search

                                                                                                                                                                              method descending

                                                                                                                                                                              descending: (descending: boolean) => IdSearchSort;

                                                                                                                                                                                class IndexExistsError

                                                                                                                                                                                class IndexExistsError extends CouchbaseError {}
                                                                                                                                                                                • Indicates that the referenced index already existed, but was expected to not yet exist for the operation.

                                                                                                                                                                                  Error Handling

                                                                                                                                                                                constructor

                                                                                                                                                                                constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                  class IndexFailureError

                                                                                                                                                                                  class IndexFailureError extends CouchbaseError {}
                                                                                                                                                                                  • Indicates that a failure occured while querying an index.

                                                                                                                                                                                    Error Handling

                                                                                                                                                                                  constructor

                                                                                                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                    class IndexNotFoundError

                                                                                                                                                                                    class IndexNotFoundError extends CouchbaseError {}
                                                                                                                                                                                    • Indicates that the referenced index does not exist.

                                                                                                                                                                                      Error Handling

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                      class IndexNotReadyError

                                                                                                                                                                                      class IndexNotReadyError extends CouchbaseError {}
                                                                                                                                                                                      • Indicates that the index was not ready yet.

                                                                                                                                                                                        Error Handling

                                                                                                                                                                                      constructor

                                                                                                                                                                                      constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                        class InternalServerFailureError

                                                                                                                                                                                        class InternalServerFailureError extends CouchbaseError {}
                                                                                                                                                                                        • Indicates some form of internal error occured on the server and the request could not be completed.

                                                                                                                                                                                          Error Handling

                                                                                                                                                                                        constructor

                                                                                                                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                          class InvalidArgumentError

                                                                                                                                                                                          class InvalidArgumentError extends CouchbaseError {}
                                                                                                                                                                                          • Indicates that one of the passed arguments was invalid.

                                                                                                                                                                                            Error Handling

                                                                                                                                                                                          constructor

                                                                                                                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                            class InvalidDurabilityLevel

                                                                                                                                                                                            class InvalidDurabilityLevel extends CouchbaseError {}
                                                                                                                                                                                            • Indicates that the specific durability level was invalid.

                                                                                                                                                                                              Error Handling

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor();

                                                                                                                                                                                              class InvalidDurabilityPersistToLevel

                                                                                                                                                                                              class InvalidDurabilityPersistToLevel extends CouchbaseError {}
                                                                                                                                                                                              • Indicates that the specific durabilityPersistTo level was invalid.

                                                                                                                                                                                                Error Handling

                                                                                                                                                                                              constructor

                                                                                                                                                                                              constructor();

                                                                                                                                                                                                class InvalidDurabilityReplicateToLevel

                                                                                                                                                                                                class InvalidDurabilityReplicateToLevel extends CouchbaseError {}
                                                                                                                                                                                                • Indicates that the specific durabilityReplicateTo level was invalid.

                                                                                                                                                                                                  Error Handling

                                                                                                                                                                                                constructor

                                                                                                                                                                                                constructor();

                                                                                                                                                                                                  class JobQueueFullError

                                                                                                                                                                                                  class JobQueueFullError extends CouchbaseError {}
                                                                                                                                                                                                  • Indicates that the job queue for the service was full and further requests will be rejected for a period of time until the queue shrinks.

                                                                                                                                                                                                    Error Handling

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                    class KeyValueErrorContext

                                                                                                                                                                                                    class KeyValueErrorContext extends ErrorContext {}
                                                                                                                                                                                                    • The error context information for a key-value operation.

                                                                                                                                                                                                      Error Handling

                                                                                                                                                                                                    property bucket

                                                                                                                                                                                                    bucket: string;
                                                                                                                                                                                                    • The name of the bucket that was being operated on.

                                                                                                                                                                                                    property cas

                                                                                                                                                                                                    cas: Cas;
                                                                                                                                                                                                    • The cas returned by the server.

                                                                                                                                                                                                    property collection

                                                                                                                                                                                                    collection: string;
                                                                                                                                                                                                    • The name of the collection that was being operated on.

                                                                                                                                                                                                    property context

                                                                                                                                                                                                    context: string;
                                                                                                                                                                                                    • The context returned by the server helping describing the error.

                                                                                                                                                                                                    property key

                                                                                                                                                                                                    key: string;
                                                                                                                                                                                                    • The key that was being operated on.

                                                                                                                                                                                                    property opaque

                                                                                                                                                                                                    opaque: number;
                                                                                                                                                                                                    • The opaque identifier for the request.

                                                                                                                                                                                                    property ref

                                                                                                                                                                                                    ref: string;
                                                                                                                                                                                                    • The reference id returned by the server for correlation in server logs.

                                                                                                                                                                                                    property scope

                                                                                                                                                                                                    scope: string;
                                                                                                                                                                                                    • The name of the scope that was being operated on.

                                                                                                                                                                                                    property status_code

                                                                                                                                                                                                    status_code: number;
                                                                                                                                                                                                    • The memcached status code returned by the server.

                                                                                                                                                                                                    class LinkExistsError

                                                                                                                                                                                                    class LinkExistsError extends CouchbaseError {}
                                                                                                                                                                                                    • Indicates that the link already exists.

                                                                                                                                                                                                      Error Handling

                                                                                                                                                                                                    constructor

                                                                                                                                                                                                    constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                      class LinkNotFoundError

                                                                                                                                                                                                      class LinkNotFoundError extends CouchbaseError {}
                                                                                                                                                                                                      • Indicates that the referenced link does not exist.

                                                                                                                                                                                                        Error Handling

                                                                                                                                                                                                      constructor

                                                                                                                                                                                                      constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                        class LookupInMacro

                                                                                                                                                                                                        class LookupInMacro {}
                                                                                                                                                                                                        • Represents a macro that can be passed to a lookup-in operation to fetch special values such as the expiry, cas, etc...

                                                                                                                                                                                                          Key-Value

                                                                                                                                                                                                        constructor

                                                                                                                                                                                                        constructor(value: string);

                                                                                                                                                                                                          property Cas

                                                                                                                                                                                                          static readonly Cas: LookupInMacro;
                                                                                                                                                                                                          • A macro which references the cas of a document.

                                                                                                                                                                                                          property Document

                                                                                                                                                                                                          static readonly Document: LookupInMacro;
                                                                                                                                                                                                          • A macro which references the entirety of the document meta-data.

                                                                                                                                                                                                          property Expiry

                                                                                                                                                                                                          static readonly Expiry: LookupInMacro;
                                                                                                                                                                                                          • A macro which references the expiry of a document.

                                                                                                                                                                                                          property IsDeleted

                                                                                                                                                                                                          static readonly IsDeleted: LookupInMacro;
                                                                                                                                                                                                          • A macro which references the deletion state of a document. This only makes sense to use in concert with the internal AccessDeleted flags, which are internal.

                                                                                                                                                                                                          property LastModified

                                                                                                                                                                                                          static readonly LastModified: LookupInMacro;
                                                                                                                                                                                                          • A macro which references the last modified time of a document.

                                                                                                                                                                                                          property RevId

                                                                                                                                                                                                          static readonly RevId: LookupInMacro;
                                                                                                                                                                                                          • A macro which references the revision id of a document.

                                                                                                                                                                                                          property SeqNo

                                                                                                                                                                                                          static readonly SeqNo: LookupInMacro;
                                                                                                                                                                                                          • A macro which references the seqno of a document.

                                                                                                                                                                                                          property ValueSizeBytes

                                                                                                                                                                                                          static readonly ValueSizeBytes: LookupInMacro;
                                                                                                                                                                                                          • A macro which references the size of a document, expressed in bytes.

                                                                                                                                                                                                          class LookupInReplicaResult

                                                                                                                                                                                                          class LookupInReplicaResult {}
                                                                                                                                                                                                          • Contains the results of a lookup-in replica operation.

                                                                                                                                                                                                            Key-Value

                                                                                                                                                                                                          constructor

                                                                                                                                                                                                          constructor(data: {
                                                                                                                                                                                                          content: LookupInResultEntry[];
                                                                                                                                                                                                          cas: Cas;
                                                                                                                                                                                                          isReplica: boolean;
                                                                                                                                                                                                          });

                                                                                                                                                                                                            property cas

                                                                                                                                                                                                            cas: Cas;
                                                                                                                                                                                                            • The cas of the document.

                                                                                                                                                                                                            property content

                                                                                                                                                                                                            content: LookupInResultEntry[];
                                                                                                                                                                                                            • A list of result entries for each sub-operation performed.

                                                                                                                                                                                                            property isReplica

                                                                                                                                                                                                            isReplica: boolean;
                                                                                                                                                                                                            • Indicates whether this result came from a replica or the primary.

                                                                                                                                                                                                            class LookupInResult

                                                                                                                                                                                                            class LookupInResult {}
                                                                                                                                                                                                            • Contains the results of a lookup-in operation.

                                                                                                                                                                                                              Key-Value

                                                                                                                                                                                                            property cas

                                                                                                                                                                                                            cas: Cas;
                                                                                                                                                                                                            • The cas of the document.

                                                                                                                                                                                                            property content

                                                                                                                                                                                                            content: LookupInResultEntry[];
                                                                                                                                                                                                            • A list of result entries for each sub-operation performed.

                                                                                                                                                                                                            property results

                                                                                                                                                                                                            results: LookupInResultEntry[];

                                                                                                                                                                                                            class LookupInResultEntry

                                                                                                                                                                                                            class LookupInResultEntry {}
                                                                                                                                                                                                            • Contains the results of a specific sub-operation within a lookup-in operation.

                                                                                                                                                                                                              Key-Value

                                                                                                                                                                                                            property error

                                                                                                                                                                                                            error: Error;
                                                                                                                                                                                                            • The error, if any, which occured when attempting to perform this sub-operation.

                                                                                                                                                                                                            property value

                                                                                                                                                                                                            value?: any;
                                                                                                                                                                                                            • The value returned by the sub-operation.

                                                                                                                                                                                                            class LookupInSpec

                                                                                                                                                                                                            class LookupInSpec {}
                                                                                                                                                                                                            • Represents a sub-operation to perform within a lookup-in operation.

                                                                                                                                                                                                              Key-Value

                                                                                                                                                                                                            property Expiry

                                                                                                                                                                                                            static readonly Expiry: LookupInMacro;
                                                                                                                                                                                                            • BUG(JSCBC-756): Previously provided access to the expiry macro for a lookup-in operation.

                                                                                                                                                                                                              Deprecated

                                                                                                                                                                                                              Use LookupInMacro.Expiry instead.

                                                                                                                                                                                                            method count

                                                                                                                                                                                                            static count: (
                                                                                                                                                                                                            path: string | LookupInMacro,
                                                                                                                                                                                                            options?: { xattr?: boolean }
                                                                                                                                                                                                            ) => LookupInSpec;
                                                                                                                                                                                                            • Returns the number of elements in the array reference by the path.

                                                                                                                                                                                                              Parameter path

                                                                                                                                                                                                              The path to the field.

                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                              Parameter

                                                                                                                                                                                                              options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                            method exists

                                                                                                                                                                                                            static exists: (
                                                                                                                                                                                                            path: string | LookupInMacro,
                                                                                                                                                                                                            options?: { xattr?: boolean }
                                                                                                                                                                                                            ) => LookupInSpec;
                                                                                                                                                                                                            • Returns whether a specific field exists in the document.

                                                                                                                                                                                                              Parameter path

                                                                                                                                                                                                              The path to the field.

                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                              Parameter

                                                                                                                                                                                                              options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                            method get

                                                                                                                                                                                                            static get: (
                                                                                                                                                                                                            path: string | LookupInMacro,
                                                                                                                                                                                                            options?: { xattr?: boolean }
                                                                                                                                                                                                            ) => LookupInSpec;
                                                                                                                                                                                                            • Creates a LookupInSpec for fetching a field from the document.

                                                                                                                                                                                                              Parameter path

                                                                                                                                                                                                              The path to the field.

                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                              Parameter

                                                                                                                                                                                                              options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                            class MatchAllSearchQuery

                                                                                                                                                                                                            class MatchAllSearchQuery extends SearchQuery {}
                                                                                                                                                                                                            • Represents a match-all search query.

                                                                                                                                                                                                              Full Text Search

                                                                                                                                                                                                            class MatchNoneSearchQuery

                                                                                                                                                                                                            class MatchNoneSearchQuery extends SearchQuery {}
                                                                                                                                                                                                            • Represents a match-none search query.

                                                                                                                                                                                                              Full Text Search

                                                                                                                                                                                                            class MatchPhraseSearchQuery

                                                                                                                                                                                                            class MatchPhraseSearchQuery extends SearchQuery {}
                                                                                                                                                                                                            • Represents a match-phrase search query.

                                                                                                                                                                                                              Full Text Search

                                                                                                                                                                                                            method analyzer

                                                                                                                                                                                                            analyzer: (analyzer: string) => MatchPhraseSearchQuery;

                                                                                                                                                                                                              method boost

                                                                                                                                                                                                              boost: (boost: number) => MatchPhraseSearchQuery;

                                                                                                                                                                                                                method field

                                                                                                                                                                                                                field: (field: string) => MatchPhraseSearchQuery;

                                                                                                                                                                                                                  class MatchSearchQuery

                                                                                                                                                                                                                  class MatchSearchQuery extends SearchQuery {}
                                                                                                                                                                                                                  • Represents a match search query.

                                                                                                                                                                                                                    Full Text Search

                                                                                                                                                                                                                  method analyzer

                                                                                                                                                                                                                  analyzer: (analyzer: string) => MatchSearchQuery;

                                                                                                                                                                                                                    method boost

                                                                                                                                                                                                                    boost: (boost: number) => MatchSearchQuery;

                                                                                                                                                                                                                      method field

                                                                                                                                                                                                                      field: (field: string) => MatchSearchQuery;

                                                                                                                                                                                                                        method fuzziness

                                                                                                                                                                                                                        fuzziness: (fuzziness: number) => MatchSearchQuery;

                                                                                                                                                                                                                          method operator

                                                                                                                                                                                                                          operator: (op: MatchOperator) => MatchSearchQuery;

                                                                                                                                                                                                                            method prefixLength

                                                                                                                                                                                                                            prefixLength: (prefixLength: number) => MatchSearchQuery;

                                                                                                                                                                                                                              class MutateInMacro

                                                                                                                                                                                                                              class MutateInMacro {}
                                                                                                                                                                                                                              • Represents a macro that can be passed to a mutate-in operation to write special values such as the expiry, cas, etc...

                                                                                                                                                                                                                                Key-Value

                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                              constructor(value: string);

                                                                                                                                                                                                                                property Cas

                                                                                                                                                                                                                                static readonly Cas: MutateInMacro;
                                                                                                                                                                                                                                • A macro which references the cas of a document.

                                                                                                                                                                                                                                property SeqNo

                                                                                                                                                                                                                                static readonly SeqNo: MutateInMacro;
                                                                                                                                                                                                                                • A macro which references the seqno of a document.

                                                                                                                                                                                                                                property ValueCrc32c

                                                                                                                                                                                                                                static readonly ValueCrc32c: MutateInMacro;
                                                                                                                                                                                                                                • A macro which references the crc32 of the value of a document.

                                                                                                                                                                                                                                class MutateInResult

                                                                                                                                                                                                                                class MutateInResult {}
                                                                                                                                                                                                                                • Contains the results of a mutate-in operation.

                                                                                                                                                                                                                                  Key-Value

                                                                                                                                                                                                                                property cas

                                                                                                                                                                                                                                cas: Cas;
                                                                                                                                                                                                                                • The updated CAS for the document.

                                                                                                                                                                                                                                property content

                                                                                                                                                                                                                                content: MutateInResultEntry[];
                                                                                                                                                                                                                                • A list of result entries for each sub-operation performed.

                                                                                                                                                                                                                                property token

                                                                                                                                                                                                                                token?: MutationToken;
                                                                                                                                                                                                                                • The token representing the mutation performed.

                                                                                                                                                                                                                                class MutateInResultEntry

                                                                                                                                                                                                                                class MutateInResultEntry {}
                                                                                                                                                                                                                                • Contains the results of a specific sub-operation within a mutate-in operation.

                                                                                                                                                                                                                                  Key-Value

                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                value: any;
                                                                                                                                                                                                                                • The resulting value after the completion of the sub-operation. This namely returned in the case of a counter operation (increment/decrement) and is not included for general operations.

                                                                                                                                                                                                                                class MutateInSpec

                                                                                                                                                                                                                                class MutateInSpec {}
                                                                                                                                                                                                                                • Represents a sub-operation to perform within a mutate-in operation.

                                                                                                                                                                                                                                  Key-Value

                                                                                                                                                                                                                                property CasPlaceholder

                                                                                                                                                                                                                                static readonly CasPlaceholder: MutateInMacro;
                                                                                                                                                                                                                                • BUG(JSCBC-756): Previously provided access to the document cas mutate macro.

                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                  Use MutateInMacro.Cas instead.

                                                                                                                                                                                                                                method arrayAddUnique

                                                                                                                                                                                                                                static arrayAddUnique: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any | MutateInMacro,
                                                                                                                                                                                                                                options?: { createPath?: boolean; multi?: boolean; xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for adding unique values to an array in a document. This operation will only add values if they do not already exist elsewhere in the array.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to add.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.createPath Whether or not the path to the field should be created if it does not already exist.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.multi If set, this enables an array of values to be passed as value, and each element of the passed array is added to the array.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method arrayAppend

                                                                                                                                                                                                                                static arrayAppend: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any | MutateInMacro,
                                                                                                                                                                                                                                options?: { createPath?: boolean; multi?: boolean; xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for adding a value to the end of an array in a document.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to add.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.createPath Whether or not the path to the field should be created if it does not already exist.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.multi If set, this enables an array of values to be passed as value, and each element of the passed array is added to the array.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method arrayInsert

                                                                                                                                                                                                                                static arrayInsert: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any | MutateInMacro,
                                                                                                                                                                                                                                options?: { createPath?: boolean; multi?: boolean; xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for adding a value to a specified location in an array in a document. The path should specify a specific index in the array and the new values are inserted at this location.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to an element of an array.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to add.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.createPath Whether or not the path to the field should be created if it does not already exist.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.multi If set, this enables an array of values to be passed as value, and each element of the passed array is added to the array.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method arrayPrepend

                                                                                                                                                                                                                                static arrayPrepend: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any | MutateInMacro,
                                                                                                                                                                                                                                options?: { createPath?: boolean; multi?: boolean; xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for adding a value to the beginning of an array in a document.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to add.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.createPath Whether or not the path to the field should be created if it does not already exist.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.multi If set, this enables an array of values to be passed as value, and each element of the passed array is added to the array.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method decrement

                                                                                                                                                                                                                                static decrement: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any,
                                                                                                                                                                                                                                options?: { createPath?: boolean; xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for decrementing the value of a field in a document.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to subtract.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.createPath Whether or not the path to the field should be created if it does not already exist.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method increment

                                                                                                                                                                                                                                static increment: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any,
                                                                                                                                                                                                                                options?: { createPath?: boolean; xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for incrementing the value of a field in a document.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to add.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.createPath Whether or not the path to the field should be created if it does not already exist.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method insert

                                                                                                                                                                                                                                static insert: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any,
                                                                                                                                                                                                                                options?: { createPath?: boolean; xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for inserting a field into the document. Failing if the field already exists at the specified path.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to insert.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.createPath Whether or not the path to the field should be created if it does not already exist.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method remove

                                                                                                                                                                                                                                static remove: (path: string, options?: { xattr?: boolean }) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for remove a field from a document.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method replace

                                                                                                                                                                                                                                static replace: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any | MutateInMacro,
                                                                                                                                                                                                                                options?: { xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for replacing a field on a document. This updates the value of the specified field, failing if the field does not exits.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to write.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                method upsert

                                                                                                                                                                                                                                static upsert: (
                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                value: any | MutateInMacro,
                                                                                                                                                                                                                                options?: { createPath?: boolean; xattr?: boolean }
                                                                                                                                                                                                                                ) => MutateInSpec;
                                                                                                                                                                                                                                • Creates a MutateInSpec for upserting a field on a document. This updates the value of the specified field, or creates the field if it does not exits.

                                                                                                                                                                                                                                  Parameter path

                                                                                                                                                                                                                                  The path to the field.

                                                                                                                                                                                                                                  Parameter value

                                                                                                                                                                                                                                  The value to write.

                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.createPath Whether or not the path to the field should be created if it does not already exist.

                                                                                                                                                                                                                                  Parameter

                                                                                                                                                                                                                                  options.xattr Whether this operation should reference the document body or the extended attributes data for the document.

                                                                                                                                                                                                                                class MutationLostError

                                                                                                                                                                                                                                class MutationLostError extends CouchbaseError {}
                                                                                                                                                                                                                                • Indicates that a mutation was lost.

                                                                                                                                                                                                                                  Error Handling

                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                  class MutationResult

                                                                                                                                                                                                                                  class MutationResult {}
                                                                                                                                                                                                                                  • Contains the results of a mutate-in operation.

                                                                                                                                                                                                                                    Key-Value

                                                                                                                                                                                                                                  property cas

                                                                                                                                                                                                                                  cas: Cas;
                                                                                                                                                                                                                                  • The updated CAS for the document.

                                                                                                                                                                                                                                  property token

                                                                                                                                                                                                                                  token?: MutationToken;
                                                                                                                                                                                                                                  • The token representing the mutation performed.

                                                                                                                                                                                                                                  class MutationState

                                                                                                                                                                                                                                  class MutationState {}
                                                                                                                                                                                                                                  • Aggregates a number of MutationToken's which have been returned by mutation operations, which can then be used when performing queries. This will guarenteed that the query includes the specified set of mutations without incurring the wait associated with request_plus level consistency.

                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                  constructor(...tokens: MutationToken[]);

                                                                                                                                                                                                                                    method add

                                                                                                                                                                                                                                    add: (...tokens: MutationToken[]) => void;
                                                                                                                                                                                                                                    • Adds a set of tokens to this state.

                                                                                                                                                                                                                                      Parameter tokens

                                                                                                                                                                                                                                      The tokens to add.

                                                                                                                                                                                                                                    class NeedOpenBucketError

                                                                                                                                                                                                                                    class NeedOpenBucketError extends CouchbaseError {}
                                                                                                                                                                                                                                    • Indicates that an cluster-level operation could not be performed as no buckets were open. This occurs with pre-6.0 clusters which were not able to fetch cluster topology without knowing the name of a bucket.

                                                                                                                                                                                                                                      Error Handling

                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                    constructor();

                                                                                                                                                                                                                                      class NumberTooBigError

                                                                                                                                                                                                                                      class NumberTooBigError extends CouchbaseError {}
                                                                                                                                                                                                                                      • Indicates that a number has grown too large.

                                                                                                                                                                                                                                        Error Handling

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                        class NumericRangeSearchQuery

                                                                                                                                                                                                                                        class NumericRangeSearchQuery extends SearchQuery {}
                                                                                                                                                                                                                                        • Represents a numeric-range search query.

                                                                                                                                                                                                                                          Full Text Search

                                                                                                                                                                                                                                        method boost

                                                                                                                                                                                                                                        boost: (boost: number) => NumericRangeSearchQuery;

                                                                                                                                                                                                                                          method field

                                                                                                                                                                                                                                          field: (field: string) => NumericRangeSearchQuery;

                                                                                                                                                                                                                                            method max

                                                                                                                                                                                                                                            max: (max: number, inclusive?: boolean) => NumericRangeSearchQuery;

                                                                                                                                                                                                                                              method min

                                                                                                                                                                                                                                              min: (min: number, inclusive?: boolean) => NumericRangeSearchQuery;

                                                                                                                                                                                                                                                class NumericSearchFacet

                                                                                                                                                                                                                                                class NumericSearchFacet extends SearchFacet {}
                                                                                                                                                                                                                                                • Provides ability to request a numeric facet.

                                                                                                                                                                                                                                                  Full Text Search

                                                                                                                                                                                                                                                method addRange

                                                                                                                                                                                                                                                addRange: (name: string, min?: number, max?: number) => NumericSearchFacet;

                                                                                                                                                                                                                                                  class Origin

                                                                                                                                                                                                                                                  class Origin {}
                                                                                                                                                                                                                                                  • Contains information about an origin for a role.

                                                                                                                                                                                                                                                    Management

                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                  name?: string;
                                                                                                                                                                                                                                                  • The name of this origin.

                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                  type: string;
                                                                                                                                                                                                                                                  • The type of this origin.

                                                                                                                                                                                                                                                  class ParsingFailureError

                                                                                                                                                                                                                                                  class ParsingFailureError extends CouchbaseError {}
                                                                                                                                                                                                                                                  • Indicates that a parsing failure occured.

                                                                                                                                                                                                                                                    Error Handling

                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                    class PasswordAuthenticator

                                                                                                                                                                                                                                                    class PasswordAuthenticator implements IPasswordAuthenticator {}
                                                                                                                                                                                                                                                    • PasswordAuthenticator implements a simple IPasswordAuthenticator.

                                                                                                                                                                                                                                                      Authentication

                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                    constructor(username: string, password: string);
                                                                                                                                                                                                                                                    • Constructs this PasswordAuthenticator with the passed username and password.

                                                                                                                                                                                                                                                      Parameter username

                                                                                                                                                                                                                                                      The username to initialize this authenticator with.

                                                                                                                                                                                                                                                      Parameter password

                                                                                                                                                                                                                                                      The password to initialize this authenticator with.

                                                                                                                                                                                                                                                    property allowed_sasl_mechanisms

                                                                                                                                                                                                                                                    allowed_sasl_mechanisms?: string[];
                                                                                                                                                                                                                                                    • The sasl mechanisms to authenticate with.

                                                                                                                                                                                                                                                    property password

                                                                                                                                                                                                                                                    password: string;
                                                                                                                                                                                                                                                    • The password that will be used to authenticate with.

                                                                                                                                                                                                                                                    property username

                                                                                                                                                                                                                                                    username: string;
                                                                                                                                                                                                                                                    • The username that will be used to authenticate with.

                                                                                                                                                                                                                                                    method ldapCompatible

                                                                                                                                                                                                                                                    static ldapCompatible: (
                                                                                                                                                                                                                                                    username: string,
                                                                                                                                                                                                                                                    password: string
                                                                                                                                                                                                                                                    ) => PasswordAuthenticator;
                                                                                                                                                                                                                                                    • Creates a LDAP compatible password authenticator which is INSECURE if not used with TLS.

                                                                                                                                                                                                                                                      Please note that this is INSECURE and will leak user credentials on the wire to eavesdroppers. This should only be enabled in trusted environments.

                                                                                                                                                                                                                                                      Parameter username

                                                                                                                                                                                                                                                      The username to initialize this authenticator with.

                                                                                                                                                                                                                                                      Parameter password

                                                                                                                                                                                                                                                      The password to initialize this authenticator with.

                                                                                                                                                                                                                                                    class PathExistsError

                                                                                                                                                                                                                                                    class PathExistsError extends CouchbaseError {}
                                                                                                                                                                                                                                                    • Indicates that the reference path already existed, but the operation expected that it did not.

                                                                                                                                                                                                                                                      Error Handling

                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                    constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                      class PathInvalidError

                                                                                                                                                                                                                                                      class PathInvalidError extends CouchbaseError {}
                                                                                                                                                                                                                                                      • Indicates that the referenced path is not valid.

                                                                                                                                                                                                                                                        Error Handling

                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                      constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                        class PathMismatchError

                                                                                                                                                                                                                                                        class PathMismatchError extends CouchbaseError {}
                                                                                                                                                                                                                                                        • Indicates that the referenced path made incorrect assumptions about the structure of a document, for instance attempting to access a field as an object when in fact it is an array.

                                                                                                                                                                                                                                                          Error Handling

                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                          class PathNotFoundError

                                                                                                                                                                                                                                                          class PathNotFoundError extends CouchbaseError {}
                                                                                                                                                                                                                                                          • Indicates that the reference path was not found.

                                                                                                                                                                                                                                                            Error Handling

                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                            class PathTooBigError

                                                                                                                                                                                                                                                            class PathTooBigError extends CouchbaseError {}
                                                                                                                                                                                                                                                            • Indicates that the specified path was too large to parse.

                                                                                                                                                                                                                                                              Error Handling

                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                            constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                              class PathTooDeepError

                                                                                                                                                                                                                                                              class PathTooDeepError extends CouchbaseError {}
                                                                                                                                                                                                                                                              • Indicates that the referenced path was too deep to parse.

                                                                                                                                                                                                                                                                Error Handling

                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                              constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                class PhraseSearchQuery

                                                                                                                                                                                                                                                                class PhraseSearchQuery extends SearchQuery {}
                                                                                                                                                                                                                                                                • Represents a phrase search query.

                                                                                                                                                                                                                                                                  Full Text Search

                                                                                                                                                                                                                                                                method boost

                                                                                                                                                                                                                                                                boost: (boost: number) => PhraseSearchQuery;

                                                                                                                                                                                                                                                                  method field

                                                                                                                                                                                                                                                                  field: (field: string) => PhraseSearchQuery;

                                                                                                                                                                                                                                                                    class PingEndpoint

                                                                                                                                                                                                                                                                    class PingEndpoint {}
                                                                                                                                                                                                                                                                    • PingEndpoint represents a single endpoint in a ping result.

                                                                                                                                                                                                                                                                      Diagnostics

                                                                                                                                                                                                                                                                    property bucket

                                                                                                                                                                                                                                                                    bucket?: string;
                                                                                                                                                                                                                                                                    • The bucket this endpoint is connected to.

                                                                                                                                                                                                                                                                    property error

                                                                                                                                                                                                                                                                    error?: any;
                                                                                                                                                                                                                                                                    • Information about errors that occured during pinging.

                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                    id: string;
                                                                                                                                                                                                                                                                    • The unique identifier for this endpoint.

                                                                                                                                                                                                                                                                    property latency

                                                                                                                                                                                                                                                                    latency: number;
                                                                                                                                                                                                                                                                    • The latency of the ping to the endpoint.

                                                                                                                                                                                                                                                                    property local

                                                                                                                                                                                                                                                                    local: string;
                                                                                                                                                                                                                                                                    • The local address of this endpoint.

                                                                                                                                                                                                                                                                    property remote

                                                                                                                                                                                                                                                                    remote: string;
                                                                                                                                                                                                                                                                    • The remote address of this endpoint.

                                                                                                                                                                                                                                                                    property state

                                                                                                                                                                                                                                                                    state: PingState;
                                                                                                                                                                                                                                                                    • The current state of this endpoint.

                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                    type: ServiceType;
                                                                                                                                                                                                                                                                    • The type of service this endpoint refers to.

                                                                                                                                                                                                                                                                    class PingResult

                                                                                                                                                                                                                                                                    class PingResult {}
                                                                                                                                                                                                                                                                    • PingResult represents the output of a ping operation.

                                                                                                                                                                                                                                                                      Diagnostics

                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                    id: string;
                                                                                                                                                                                                                                                                    • The unique identifier for this report.

                                                                                                                                                                                                                                                                    property sdk

                                                                                                                                                                                                                                                                    sdk: string;
                                                                                                                                                                                                                                                                    • The name of the SDK which generated this report.

                                                                                                                                                                                                                                                                    property services

                                                                                                                                                                                                                                                                    services: { [serviceType: string]: PingEndpoint[] };
                                                                                                                                                                                                                                                                    • A list of service endpoints and their ping results.

                                                                                                                                                                                                                                                                    property version

                                                                                                                                                                                                                                                                    version: number;
                                                                                                                                                                                                                                                                    • The version number of this report.

                                                                                                                                                                                                                                                                    method toJSON

                                                                                                                                                                                                                                                                    toJSON: () => JsonPingReport;
                                                                                                                                                                                                                                                                    • Returns a JSON formatted ping report.

                                                                                                                                                                                                                                                                    class PlanningFailureError

                                                                                                                                                                                                                                                                    class PlanningFailureError extends CouchbaseError {}
                                                                                                                                                                                                                                                                    • Indicates that a failure occurred while planning a query.

                                                                                                                                                                                                                                                                      Error Handling

                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                    constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                      class PrefixScan

                                                                                                                                                                                                                                                                      class PrefixScan implements ScanType {}
                                                                                                                                                                                                                                                                      • A PrefixScan scan type selects every document whose ID starts with a certain prefix.

                                                                                                                                                                                                                                                                        Key-Value

                                                                                                                                                                                                                                                                      property prefix

                                                                                                                                                                                                                                                                      prefix: string;
                                                                                                                                                                                                                                                                      • PrefixScan prefix.

                                                                                                                                                                                                                                                                      method getScanType

                                                                                                                                                                                                                                                                      getScanType: () => string;
                                                                                                                                                                                                                                                                      • Returns string representation of scan type.

                                                                                                                                                                                                                                                                      class PrefixSearchQuery

                                                                                                                                                                                                                                                                      class PrefixSearchQuery extends SearchQuery {}
                                                                                                                                                                                                                                                                      • Represents a prefix search query.

                                                                                                                                                                                                                                                                        Full Text Search

                                                                                                                                                                                                                                                                      method boost

                                                                                                                                                                                                                                                                      boost: (boost: number) => PrefixSearchQuery;

                                                                                                                                                                                                                                                                        method field

                                                                                                                                                                                                                                                                        field: (field: string) => PrefixSearchQuery;

                                                                                                                                                                                                                                                                          class PreparedStatementFailureError

                                                                                                                                                                                                                                                                          class PreparedStatementFailureError extends CouchbaseError {}
                                                                                                                                                                                                                                                                          • Indicates that an error occurred with a prepared statement.

                                                                                                                                                                                                                                                                            Error Handling

                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                            class QueryErrorContext

                                                                                                                                                                                                                                                                            class QueryErrorContext extends ErrorContext {}
                                                                                                                                                                                                                                                                            • The error context information for a query operation.

                                                                                                                                                                                                                                                                              Error Handling

                                                                                                                                                                                                                                                                            property client_context_id

                                                                                                                                                                                                                                                                            client_context_id: string;
                                                                                                                                                                                                                                                                            • The client context id which was sent to the service for correlation between requests and responses.

                                                                                                                                                                                                                                                                            property http_response_body

                                                                                                                                                                                                                                                                            http_response_body: string;
                                                                                                                                                                                                                                                                            • The http response body which was received.

                                                                                                                                                                                                                                                                            property http_response_code

                                                                                                                                                                                                                                                                            http_response_code: number;
                                                                                                                                                                                                                                                                            • The http response status code which was received.

                                                                                                                                                                                                                                                                            property parameters

                                                                                                                                                                                                                                                                            parameters: any;
                                                                                                                                                                                                                                                                            • A list of the parameters in use for the operation.

                                                                                                                                                                                                                                                                            property statement

                                                                                                                                                                                                                                                                            statement: string;
                                                                                                                                                                                                                                                                            • The statement that was being executed when the error occured.

                                                                                                                                                                                                                                                                            class QueryIndex

                                                                                                                                                                                                                                                                            class QueryIndex {}
                                                                                                                                                                                                                                                                            • Contains a specific index configuration for the query service.

                                                                                                                                                                                                                                                                              Management

                                                                                                                                                                                                                                                                            property bucketName

                                                                                                                                                                                                                                                                            bucketName?: string;
                                                                                                                                                                                                                                                                            • The bucket that this index is for.

                                                                                                                                                                                                                                                                            property collectionName

                                                                                                                                                                                                                                                                            collectionName?: string;
                                                                                                                                                                                                                                                                            • The collection that this index is for.

                                                                                                                                                                                                                                                                            property condition

                                                                                                                                                                                                                                                                            condition?: string;
                                                                                                                                                                                                                                                                            • The conditional expression to limit the indexes scope.

                                                                                                                                                                                                                                                                            property indexKey

                                                                                                                                                                                                                                                                            indexKey: string[];
                                                                                                                                                                                                                                                                            • The keys for this index.

                                                                                                                                                                                                                                                                            property isPrimary

                                                                                                                                                                                                                                                                            isPrimary: boolean;
                                                                                                                                                                                                                                                                            • Whether this is a primary or secondary index.

                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                            • The name of the index.

                                                                                                                                                                                                                                                                            property partition

                                                                                                                                                                                                                                                                            partition?: string;
                                                                                                                                                                                                                                                                            • Information about the partitioning of this index.

                                                                                                                                                                                                                                                                            property scopeName

                                                                                                                                                                                                                                                                            scopeName?: string;
                                                                                                                                                                                                                                                                            • The scope that this index is for.

                                                                                                                                                                                                                                                                            property state

                                                                                                                                                                                                                                                                            state: string;
                                                                                                                                                                                                                                                                            • The current state of the index.

                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                            type: string;
                                                                                                                                                                                                                                                                            • The type of index.

                                                                                                                                                                                                                                                                            class QueryIndexManager

                                                                                                                                                                                                                                                                            class QueryIndexManager {}
                                                                                                                                                                                                                                                                            • QueryIndexManager provides an interface for managing the query indexes on the cluster.

                                                                                                                                                                                                                                                                              Management

                                                                                                                                                                                                                                                                            method buildDeferredIndexes

                                                                                                                                                                                                                                                                            buildDeferredIndexes: (
                                                                                                                                                                                                                                                                            bucketName: string,
                                                                                                                                                                                                                                                                            options?: BuildQueryIndexOptions,
                                                                                                                                                                                                                                                                            callback?: NodeCallback<string[]>
                                                                                                                                                                                                                                                                            ) => Promise<string[]>;
                                                                                                                                                                                                                                                                            • Starts building any indexes which were previously created with deferred=true.

                                                                                                                                                                                                                                                                              Parameter bucketName

                                                                                                                                                                                                                                                                              The name of the bucket to perform the build on.

                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                            method createIndex

                                                                                                                                                                                                                                                                            createIndex: (
                                                                                                                                                                                                                                                                            bucketName: string,
                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                            keys: string[],
                                                                                                                                                                                                                                                                            options?: CreateQueryIndexOptions,
                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                            • Creates a new query index.

                                                                                                                                                                                                                                                                              Parameter bucketName

                                                                                                                                                                                                                                                                              The name of the bucket this index is for.

                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                              The name of the new index.

                                                                                                                                                                                                                                                                              Parameter keys

                                                                                                                                                                                                                                                                              The keys which this index should cover.

                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                            method createPrimaryIndex

                                                                                                                                                                                                                                                                            createPrimaryIndex: (
                                                                                                                                                                                                                                                                            bucketName: string,
                                                                                                                                                                                                                                                                            options?: CreatePrimaryQueryIndexOptions,
                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                            • Creates a new primary query index.

                                                                                                                                                                                                                                                                              Parameter bucketName

                                                                                                                                                                                                                                                                              The name of the bucket this index is for.

                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                            method dropIndex

                                                                                                                                                                                                                                                                            dropIndex: (
                                                                                                                                                                                                                                                                            bucketName: string,
                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                            options?: DropQueryIndexOptions,
                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                            • Drops an existing query index.

                                                                                                                                                                                                                                                                              Parameter bucketName

                                                                                                                                                                                                                                                                              The name of the bucket containing the index to drop.

                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                              The name of the index to drop.

                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                            method dropPrimaryIndex

                                                                                                                                                                                                                                                                            dropPrimaryIndex: (
                                                                                                                                                                                                                                                                            bucketName: string,
                                                                                                                                                                                                                                                                            options?: DropPrimaryQueryIndexOptions,
                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                            • Drops an existing primary index.

                                                                                                                                                                                                                                                                              Parameter bucketName

                                                                                                                                                                                                                                                                              The name of the bucket containing the primary index to drop.

                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                            method getAllIndexes

                                                                                                                                                                                                                                                                            getAllIndexes: (
                                                                                                                                                                                                                                                                            bucketName: string,
                                                                                                                                                                                                                                                                            options?: GetAllQueryIndexesOptions,
                                                                                                                                                                                                                                                                            callback?: NodeCallback<QueryIndex[]>
                                                                                                                                                                                                                                                                            ) => Promise<QueryIndex[]>;
                                                                                                                                                                                                                                                                            • Returns a list of indexes for a specific bucket.

                                                                                                                                                                                                                                                                              Parameter bucketName

                                                                                                                                                                                                                                                                              The name of the bucket to fetch indexes for.

                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                            method watchIndexes

                                                                                                                                                                                                                                                                            watchIndexes: (
                                                                                                                                                                                                                                                                            bucketName: string,
                                                                                                                                                                                                                                                                            indexNames: string[],
                                                                                                                                                                                                                                                                            timeout: number,
                                                                                                                                                                                                                                                                            options?: WatchQueryIndexOptions,
                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                            • Waits for a number of indexes to finish creation and be ready to use.

                                                                                                                                                                                                                                                                              Parameter bucketName

                                                                                                                                                                                                                                                                              The name of the bucket to watch for indexes on.

                                                                                                                                                                                                                                                                              Parameter indexNames

                                                                                                                                                                                                                                                                              The names of the indexes to watch.

                                                                                                                                                                                                                                                                              Parameter timeout

                                                                                                                                                                                                                                                                              The maximum time to wait for the index, expressed in milliseconds.

                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                            class QueryMetaData

                                                                                                                                                                                                                                                                            class QueryMetaData {}
                                                                                                                                                                                                                                                                            • Contains the meta-data that is returend from a query.

                                                                                                                                                                                                                                                                              Query

                                                                                                                                                                                                                                                                            property clientContextId

                                                                                                                                                                                                                                                                            clientContextId: string;
                                                                                                                                                                                                                                                                            • The client context id which is assoicated with the executed query.

                                                                                                                                                                                                                                                                            property metrics

                                                                                                                                                                                                                                                                            metrics?: QueryMetrics;
                                                                                                                                                                                                                                                                            • Various metrics which are made available by the query engine.

                                                                                                                                                                                                                                                                            property profile

                                                                                                                                                                                                                                                                            profile?: any;
                                                                                                                                                                                                                                                                            • Various profiling details that were generated during execution of the query.

                                                                                                                                                                                                                                                                            property requestId

                                                                                                                                                                                                                                                                            requestId: string;
                                                                                                                                                                                                                                                                            • The request ID which is associated with the executed query.

                                                                                                                                                                                                                                                                            property signature

                                                                                                                                                                                                                                                                            signature?: any;
                                                                                                                                                                                                                                                                            • Provides the signature of the query.

                                                                                                                                                                                                                                                                            property status

                                                                                                                                                                                                                                                                            status: QueryStatus;
                                                                                                                                                                                                                                                                            • The status of the query at the time the query meta-data was generated.

                                                                                                                                                                                                                                                                            property warnings

                                                                                                                                                                                                                                                                            warnings: QueryWarning[];
                                                                                                                                                                                                                                                                            • Any warnings that occurred during the execution of the query.

                                                                                                                                                                                                                                                                            class QueryMetrics

                                                                                                                                                                                                                                                                            class QueryMetrics {}
                                                                                                                                                                                                                                                                            • Contains various metrics that are returned by the server following the execution of a query.

                                                                                                                                                                                                                                                                              Query

                                                                                                                                                                                                                                                                            property elapsedTime

                                                                                                                                                                                                                                                                            elapsedTime: number;
                                                                                                                                                                                                                                                                            • The total amount of time spent running the query, in milliseconds.

                                                                                                                                                                                                                                                                            property errorCount

                                                                                                                                                                                                                                                                            errorCount: number;
                                                                                                                                                                                                                                                                            • The total number of errors which were encountered during the execution of the query.

                                                                                                                                                                                                                                                                            property executionTime

                                                                                                                                                                                                                                                                            executionTime: number;
                                                                                                                                                                                                                                                                            • The total amount of time spent executing the query, in milliseconds.

                                                                                                                                                                                                                                                                            property mutationCount

                                                                                                                                                                                                                                                                            mutationCount: number;
                                                                                                                                                                                                                                                                            • The total number of rows which were altered by the query.

                                                                                                                                                                                                                                                                            property resultCount

                                                                                                                                                                                                                                                                            resultCount: number;
                                                                                                                                                                                                                                                                            • The total number of rows which were part of the result set.

                                                                                                                                                                                                                                                                            property resultSize

                                                                                                                                                                                                                                                                            resultSize: number;
                                                                                                                                                                                                                                                                            • The total number of bytes which were generated as part of the result set.

                                                                                                                                                                                                                                                                            property sortCount

                                                                                                                                                                                                                                                                            sortCount: number;
                                                                                                                                                                                                                                                                            • The total number of rows which were part of the sorting for the query.

                                                                                                                                                                                                                                                                            property warningCount

                                                                                                                                                                                                                                                                            warningCount: number;
                                                                                                                                                                                                                                                                            • The total number of warnings which were encountered during the execution of the query.

                                                                                                                                                                                                                                                                            class QueryResult

                                                                                                                                                                                                                                                                            class QueryResult<TRow = any> {}
                                                                                                                                                                                                                                                                            • Contains the results of a query.

                                                                                                                                                                                                                                                                              Query

                                                                                                                                                                                                                                                                            property meta

                                                                                                                                                                                                                                                                            meta: QueryMetaData;
                                                                                                                                                                                                                                                                            • The meta-data which has been returned by the query.

                                                                                                                                                                                                                                                                            property rows

                                                                                                                                                                                                                                                                            rows: TRow[];
                                                                                                                                                                                                                                                                            • The rows which have been returned by the query.

                                                                                                                                                                                                                                                                            class QueryStringSearchQuery

                                                                                                                                                                                                                                                                            class QueryStringSearchQuery extends SearchQuery {}
                                                                                                                                                                                                                                                                            • Represents a query-string search query.

                                                                                                                                                                                                                                                                              Full Text Search

                                                                                                                                                                                                                                                                            method boost

                                                                                                                                                                                                                                                                            boost: (boost: number) => QueryStringSearchQuery;

                                                                                                                                                                                                                                                                              class QueryWarning

                                                                                                                                                                                                                                                                              class QueryWarning {}
                                                                                                                                                                                                                                                                              • Contains information about a warning which occurred during the execution of a query.

                                                                                                                                                                                                                                                                                Query

                                                                                                                                                                                                                                                                              property code

                                                                                                                                                                                                                                                                              code: number;
                                                                                                                                                                                                                                                                              • The numeric code associated with the warning which occurred.

                                                                                                                                                                                                                                                                              property message

                                                                                                                                                                                                                                                                              message: string;
                                                                                                                                                                                                                                                                              • A human readable representation of the warning which occurred.

                                                                                                                                                                                                                                                                              class QuotaLimitedError

                                                                                                                                                                                                                                                                              class QuotaLimitedError extends CouchbaseError {}
                                                                                                                                                                                                                                                                              • Indicates that a quota limit was exceeded while attempting to execute the operation.

                                                                                                                                                                                                                                                                                Error Handling

                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                              constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                class RangeScan

                                                                                                                                                                                                                                                                                class RangeScan implements ScanType {}
                                                                                                                                                                                                                                                                                • A RangeScan performs a scan on a range of keys with the range specified through a start and end ScanTerm.

                                                                                                                                                                                                                                                                                  Key-Value

                                                                                                                                                                                                                                                                                property end

                                                                                                                                                                                                                                                                                end?: ScanTerm;
                                                                                                                                                                                                                                                                                • RangeScan end term.

                                                                                                                                                                                                                                                                                property start

                                                                                                                                                                                                                                                                                start?: ScanTerm;
                                                                                                                                                                                                                                                                                • RangeScan start term.

                                                                                                                                                                                                                                                                                method getScanType

                                                                                                                                                                                                                                                                                getScanType: () => string;
                                                                                                                                                                                                                                                                                • Returns string representation of scan type.

                                                                                                                                                                                                                                                                                class RateLimitedError

                                                                                                                                                                                                                                                                                class RateLimitedError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                • Indicates that a rate limit was exceeded while attempting to execute the operation.

                                                                                                                                                                                                                                                                                  Error Handling

                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                  class RawBinaryTranscoder

                                                                                                                                                                                                                                                                                  class RawBinaryTranscoder implements Transcoder {}
                                                                                                                                                                                                                                                                                  • The raw binary transcoder provides an explicit mechanism for storing and retrieving raw byte data.

                                                                                                                                                                                                                                                                                    Key-Value

                                                                                                                                                                                                                                                                                  method decode

                                                                                                                                                                                                                                                                                  decode: (bytes: Buffer, flags: number) => any;
                                                                                                                                                                                                                                                                                  • Decodes a buffer and flags tuple back to the original type of the document.

                                                                                                                                                                                                                                                                                    Parameter bytes

                                                                                                                                                                                                                                                                                    The bytes that were previously encoded.

                                                                                                                                                                                                                                                                                    Parameter flags

                                                                                                                                                                                                                                                                                    The flags associated with the data.

                                                                                                                                                                                                                                                                                  method encode

                                                                                                                                                                                                                                                                                  encode: (value: Buffer) => [Buffer, number];
                                                                                                                                                                                                                                                                                  • Encodes the specified value, returning a buffer and flags that are stored to the server and later used for decoding.

                                                                                                                                                                                                                                                                                    Parameter value

                                                                                                                                                                                                                                                                                    The value to encode.

                                                                                                                                                                                                                                                                                  class RawJsonTranscoder

                                                                                                                                                                                                                                                                                  class RawJsonTranscoder implements Transcoder {}
                                                                                                                                                                                                                                                                                  • The raw JSON transcoder provides an explicit mechanism for storing and retrieving JSON data.

                                                                                                                                                                                                                                                                                    Key-Value

                                                                                                                                                                                                                                                                                  method decode

                                                                                                                                                                                                                                                                                  decode: (bytes: Buffer, flags: number) => Buffer;
                                                                                                                                                                                                                                                                                  • Decodes a buffer and flags tuple back to the original type of the document.

                                                                                                                                                                                                                                                                                    Parameter bytes

                                                                                                                                                                                                                                                                                    The bytes that were previously encoded.

                                                                                                                                                                                                                                                                                    Parameter flags

                                                                                                                                                                                                                                                                                    The flags associated with the data.

                                                                                                                                                                                                                                                                                  method encode

                                                                                                                                                                                                                                                                                  encode: (value: string) => [Buffer, number];
                                                                                                                                                                                                                                                                                  • Encodes the specified value, returning a buffer and flags that are stored to the server and later used for decoding.

                                                                                                                                                                                                                                                                                    Parameter value

                                                                                                                                                                                                                                                                                    The value to encode.

                                                                                                                                                                                                                                                                                  class RawStringTranscoder

                                                                                                                                                                                                                                                                                  class RawStringTranscoder implements Transcoder {}
                                                                                                                                                                                                                                                                                  • The raw string transcoder provides an explicit mechanism for storing and retrieving raw string data.

                                                                                                                                                                                                                                                                                    Key-Value

                                                                                                                                                                                                                                                                                  method decode

                                                                                                                                                                                                                                                                                  decode: (bytes: Buffer, flags: number) => string;
                                                                                                                                                                                                                                                                                  • Decodes a buffer and flags tuple back to the original type of the document.

                                                                                                                                                                                                                                                                                    Parameter bytes

                                                                                                                                                                                                                                                                                    The bytes that were previously encoded.

                                                                                                                                                                                                                                                                                    Parameter flags

                                                                                                                                                                                                                                                                                    The flags associated with the data.

                                                                                                                                                                                                                                                                                  method encode

                                                                                                                                                                                                                                                                                  encode: (value: string) => [Buffer, number];
                                                                                                                                                                                                                                                                                  • Encodes the specified value, returning a buffer and flags that are stored to the server and later used for decoding.

                                                                                                                                                                                                                                                                                    Parameter value

                                                                                                                                                                                                                                                                                    The value to encode.

                                                                                                                                                                                                                                                                                  class RegexpSearchQuery

                                                                                                                                                                                                                                                                                  class RegexpSearchQuery extends SearchQuery {}
                                                                                                                                                                                                                                                                                  • Represents a regexp search query.

                                                                                                                                                                                                                                                                                    Full Text Search

                                                                                                                                                                                                                                                                                  method boost

                                                                                                                                                                                                                                                                                  boost: (boost: number) => RegexpSearchQuery;

                                                                                                                                                                                                                                                                                    method field

                                                                                                                                                                                                                                                                                    field: (field: string) => RegexpSearchQuery;

                                                                                                                                                                                                                                                                                      class RequestCanceledError

                                                                                                                                                                                                                                                                                      class RequestCanceledError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                      • Indicates that the request was explicitly cancelled.

                                                                                                                                                                                                                                                                                        Error Handling

                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                      constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                        class Role

                                                                                                                                                                                                                                                                                        class Role {}
                                                                                                                                                                                                                                                                                        • Contains information about a role.

                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                        property bucket

                                                                                                                                                                                                                                                                                        bucket: string;
                                                                                                                                                                                                                                                                                        • The bucket this role applies to.

                                                                                                                                                                                                                                                                                        property collection

                                                                                                                                                                                                                                                                                        collection: string;
                                                                                                                                                                                                                                                                                        • The collection this role applies to.

                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                        • The name of the role.

                                                                                                                                                                                                                                                                                        property scope

                                                                                                                                                                                                                                                                                        scope: string;
                                                                                                                                                                                                                                                                                        • The scope this role applies to.

                                                                                                                                                                                                                                                                                        class RoleAndDescription

                                                                                                                                                                                                                                                                                        class RoleAndDescription extends Role {}
                                                                                                                                                                                                                                                                                        • Contains information about a role along with its description.

                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                        description: string;
                                                                                                                                                                                                                                                                                        • The description of this role.

                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                        displayName: string;
                                                                                                                                                                                                                                                                                        • The user-friendly display name for this role.

                                                                                                                                                                                                                                                                                        class RoleAndOrigin

                                                                                                                                                                                                                                                                                        class RoleAndOrigin extends Role {}
                                                                                                                                                                                                                                                                                        • Contains information about a role along with its origin.

                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                        property origins

                                                                                                                                                                                                                                                                                        origins: Origin[];
                                                                                                                                                                                                                                                                                        • The origins for this role.

                                                                                                                                                                                                                                                                                        class S3ExternalAnalyticsLink
                                                                                                                                                                                                                                                                                        extends AnalyticsLink
                                                                                                                                                                                                                                                                                        implements IS3ExternalAnalyticsLink {}
                                                                                                                                                                                                                                                                                        • Provides information about a analytics remote S3 link.

                                                                                                                                                                                                                                                                                        property accessKeyId

                                                                                                                                                                                                                                                                                        accessKeyId: string;
                                                                                                                                                                                                                                                                                        • The AWS S3 access key.

                                                                                                                                                                                                                                                                                        property dataverse

                                                                                                                                                                                                                                                                                        dataverse: string;
                                                                                                                                                                                                                                                                                        • The dataverse that this link belongs to.

                                                                                                                                                                                                                                                                                        property linkType

                                                                                                                                                                                                                                                                                        linkType: string;
                                                                                                                                                                                                                                                                                        • Specifies what type of analytics link this represents.

                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                        • The name of this link.

                                                                                                                                                                                                                                                                                        property region

                                                                                                                                                                                                                                                                                        region: string;
                                                                                                                                                                                                                                                                                        • The AWS S3 region.

                                                                                                                                                                                                                                                                                        property secretAccessKey

                                                                                                                                                                                                                                                                                        secretAccessKey?: string;
                                                                                                                                                                                                                                                                                        • The AWS S3 secret key.

                                                                                                                                                                                                                                                                                        property serviceEndpoint

                                                                                                                                                                                                                                                                                        serviceEndpoint?: string;
                                                                                                                                                                                                                                                                                        • The AWS S3 service endpoint.

                                                                                                                                                                                                                                                                                        property sessionToken

                                                                                                                                                                                                                                                                                        sessionToken?: string;
                                                                                                                                                                                                                                                                                        • The AWS S3 token if temporary credentials are provided. Only available in Couchbase Server 7.0 and above.

                                                                                                                                                                                                                                                                                        method validate

                                                                                                                                                                                                                                                                                        validate: () => void;
                                                                                                                                                                                                                                                                                        • Validates the S3ExternalAnalyticsLink.

                                                                                                                                                                                                                                                                                        class SamplingScan

                                                                                                                                                                                                                                                                                        class SamplingScan implements ScanType {}
                                                                                                                                                                                                                                                                                        • A SamplingScan performs a scan on a random sampling of keys with the sampling bounded by a limit.

                                                                                                                                                                                                                                                                                          Key-Value

                                                                                                                                                                                                                                                                                        property limit

                                                                                                                                                                                                                                                                                        limit: number;
                                                                                                                                                                                                                                                                                        • SamplingScan limit.

                                                                                                                                                                                                                                                                                        property seed

                                                                                                                                                                                                                                                                                        seed?: number;
                                                                                                                                                                                                                                                                                        • SamplingScan seed.

                                                                                                                                                                                                                                                                                        method getScanType

                                                                                                                                                                                                                                                                                        getScanType: () => string;
                                                                                                                                                                                                                                                                                        • Returns string representation of scan type.

                                                                                                                                                                                                                                                                                        class ScanResult

                                                                                                                                                                                                                                                                                        class ScanResult {}
                                                                                                                                                                                                                                                                                        • Contains the results of a Range or Sampling Scan operation.

                                                                                                                                                                                                                                                                                          Key-Value

                                                                                                                                                                                                                                                                                        property cas

                                                                                                                                                                                                                                                                                        cas?: Cas;
                                                                                                                                                                                                                                                                                        • The CAS of the document.

                                                                                                                                                                                                                                                                                        property content

                                                                                                                                                                                                                                                                                        content?: any;
                                                                                                                                                                                                                                                                                        • The content of the document.

                                                                                                                                                                                                                                                                                        property expiryTime

                                                                                                                                                                                                                                                                                        expiryTime?: number;

                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                        id: string;
                                                                                                                                                                                                                                                                                        • The content of the document.

                                                                                                                                                                                                                                                                                        class ScanTerm

                                                                                                                                                                                                                                                                                        class ScanTerm {}
                                                                                                                                                                                                                                                                                        • Represents a search term for a RangeScan.

                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                        property exclusive

                                                                                                                                                                                                                                                                                        exclusive?: boolean;
                                                                                                                                                                                                                                                                                        • Set to true for the scan term to be exclusive. Defaults to false (inclusive).

                                                                                                                                                                                                                                                                                        property term

                                                                                                                                                                                                                                                                                        term: string;

                                                                                                                                                                                                                                                                                        class Scope

                                                                                                                                                                                                                                                                                        class Scope {}
                                                                                                                                                                                                                                                                                        • Exposes the operations which are available to be performed against a scope. Namely the ability to access to Collections for performing operations.

                                                                                                                                                                                                                                                                                          Core

                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                        readonly name: string;
                                                                                                                                                                                                                                                                                        • The name of the scope this Scope object references.

                                                                                                                                                                                                                                                                                        method analyticsQuery

                                                                                                                                                                                                                                                                                        analyticsQuery: <TRow = any>(
                                                                                                                                                                                                                                                                                        statement: string,
                                                                                                                                                                                                                                                                                        options?: AnalyticsQueryOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<AnalyticsResult<TRow>>
                                                                                                                                                                                                                                                                                        ) => StreamableRowPromise<AnalyticsResult<TRow>, TRow, AnalyticsMetaData>;
                                                                                                                                                                                                                                                                                        • Executes an analytics query against the cluster scoped this scope.

                                                                                                                                                                                                                                                                                          Parameter statement

                                                                                                                                                                                                                                                                                          The analytics statement to execute.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method collection

                                                                                                                                                                                                                                                                                        collection: (collectionName: string) => Collection;
                                                                                                                                                                                                                                                                                        • Creates a Collection object reference to a specific collection.

                                                                                                                                                                                                                                                                                          Parameter collectionName

                                                                                                                                                                                                                                                                                          The name of the collection to reference.

                                                                                                                                                                                                                                                                                        method eventingFunctions

                                                                                                                                                                                                                                                                                        eventingFunctions: () => ScopeEventingFunctionManager;
                                                                                                                                                                                                                                                                                        • Returns a ScopeEventingFunctionManager which can be used to manage the eventing functions of this scope. Uncommitted: This API is subject to change in the future.

                                                                                                                                                                                                                                                                                        method query

                                                                                                                                                                                                                                                                                        query: <TRow = any>(
                                                                                                                                                                                                                                                                                        statement: string,
                                                                                                                                                                                                                                                                                        options?: QueryOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<QueryResult<TRow>>
                                                                                                                                                                                                                                                                                        ) => StreamableRowPromise<QueryResult<TRow>, TRow, QueryMetaData>;
                                                                                                                                                                                                                                                                                        • Executes a N1QL query against the cluster scoped to this scope.

                                                                                                                                                                                                                                                                                          Parameter statement

                                                                                                                                                                                                                                                                                          The N1QL statement to execute.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method search

                                                                                                                                                                                                                                                                                        search: (
                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                        request: SearchRequest,
                                                                                                                                                                                                                                                                                        options?: SearchQueryOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<SearchResult>
                                                                                                                                                                                                                                                                                        ) => StreamableRowPromise<SearchResult, SearchRow, SearchMetaData>;
                                                                                                                                                                                                                                                                                        • Executes a search query against the scope.

                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                          The name of the index to query.

                                                                                                                                                                                                                                                                                          Parameter request

                                                                                                                                                                                                                                                                                          The SearchRequest describing the search to execute.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method searchIndexes

                                                                                                                                                                                                                                                                                        searchIndexes: () => ScopeSearchIndexManager;
                                                                                                                                                                                                                                                                                        • Returns a SearchIndexManager which can be used to manage the search indexes of this scope.

                                                                                                                                                                                                                                                                                        class ScopeEventingFunctionManager

                                                                                                                                                                                                                                                                                        class ScopeEventingFunctionManager {}
                                                                                                                                                                                                                                                                                        • ScopeEventingFunctionManager provides an interface for managing the eventing functions on the scope. Uncommitted: This API is subject to change in the future.

                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                        method deployFunction

                                                                                                                                                                                                                                                                                        deployFunction: (
                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                        options?: DeployFunctionOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                        • Deploys an eventing function.

                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                          The name of the eventing function to deploy.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method dropFunction

                                                                                                                                                                                                                                                                                        dropFunction: (
                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                        options?: DropFunctionOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                        • Deletes an eventing function.

                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                          The name of the eventing function to delete.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method functionsStatus

                                                                                                                                                                                                                                                                                        functionsStatus: (
                                                                                                                                                                                                                                                                                        options?: FunctionsStatusOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<EventingState>
                                                                                                                                                                                                                                                                                        ) => Promise<EventingState>;
                                                                                                                                                                                                                                                                                        • Fetches the status of all eventing functions.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method getAllFunctions

                                                                                                                                                                                                                                                                                        getAllFunctions: (
                                                                                                                                                                                                                                                                                        options?: GetAllFunctionsOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<EventingFunction[]>
                                                                                                                                                                                                                                                                                        ) => Promise<EventingFunction[]>;
                                                                                                                                                                                                                                                                                        • Fetches all eventing functions.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method getFunction

                                                                                                                                                                                                                                                                                        getFunction: (
                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                        options?: GetFunctionOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<EventingFunction>
                                                                                                                                                                                                                                                                                        ) => Promise<EventingFunction>;
                                                                                                                                                                                                                                                                                        • Fetches a specific eventing function.

                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                          The name of the eventing function to fetch.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method pauseFunction

                                                                                                                                                                                                                                                                                        pauseFunction: (
                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                        options?: PauseFunctionOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                        • Pauses an eventing function.

                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                          The name of the eventing function to pause.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method resumeFunction

                                                                                                                                                                                                                                                                                        resumeFunction: (
                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                        options?: ResumeFunctionOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                        • Resumes an eventing function.

                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                          The name of the eventing function to resume.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method undeployFunction

                                                                                                                                                                                                                                                                                        undeployFunction: (
                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                        options?: DeployFunctionOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                        • Undeploys an eventing function.

                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                          The name of the eventing function to undeploy.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        method upsertFunction

                                                                                                                                                                                                                                                                                        upsertFunction: (
                                                                                                                                                                                                                                                                                        functionDefinition: EventingFunction,
                                                                                                                                                                                                                                                                                        options?: UpsertFunctionOptions,
                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                        • Creates or updates an eventing function.

                                                                                                                                                                                                                                                                                          Parameter functionDefinition

                                                                                                                                                                                                                                                                                          The description of the eventing function to upsert.

                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                        class ScopeExistsError

                                                                                                                                                                                                                                                                                        class ScopeExistsError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                        • Indicates that the referenced scope already exists, but the operation expected that it did not.

                                                                                                                                                                                                                                                                                          Error Handling

                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                          class ScopeNotFoundError

                                                                                                                                                                                                                                                                                          class ScopeNotFoundError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                          • Indicates that the referenced scope does not exist.

                                                                                                                                                                                                                                                                                            Error Handling

                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                            class ScopeSearchIndexManager

                                                                                                                                                                                                                                                                                            class ScopeSearchIndexManager {}
                                                                                                                                                                                                                                                                                            • SearchIndexManager provides an interface for managing the search indexes on the cluster.

                                                                                                                                                                                                                                                                                              Management

                                                                                                                                                                                                                                                                                            method allowQuerying

                                                                                                                                                                                                                                                                                            allowQuerying: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: AllowSearchQueryingOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                            • Enables querying of an index.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to enable querying for.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method analyzeDocument

                                                                                                                                                                                                                                                                                            analyzeDocument: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            document: any,
                                                                                                                                                                                                                                                                                            options?: AnalyzeSearchDocumentOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<any>
                                                                                                                                                                                                                                                                                            ) => Promise<any>;
                                                                                                                                                                                                                                                                                            • Performs analysis of a specific document by an index.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to use for the analysis.

                                                                                                                                                                                                                                                                                              Parameter document

                                                                                                                                                                                                                                                                                              The document to analyze.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method disallowQuerying

                                                                                                                                                                                                                                                                                            disallowQuerying: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: DisallowSearchQueryingOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                            • Disables querying of an index.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to disable querying for.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method dropIndex

                                                                                                                                                                                                                                                                                            dropIndex: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: DropSearchIndexOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                            • Drops an index.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to drop.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method freezePlan

                                                                                                                                                                                                                                                                                            freezePlan: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: FreezeSearchPlanOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                            • Freezes the indexing plan for execution of queries.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to freeze the plan of.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method getAllIndexes

                                                                                                                                                                                                                                                                                            getAllIndexes: (
                                                                                                                                                                                                                                                                                            options?: GetAllSearchIndexesOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<SearchIndex[]>
                                                                                                                                                                                                                                                                                            ) => Promise<SearchIndex[]>;
                                                                                                                                                                                                                                                                                            • Returns a list of all existing indexes.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method getIndex

                                                                                                                                                                                                                                                                                            getIndex: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: GetSearchIndexOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<SearchIndex>
                                                                                                                                                                                                                                                                                            ) => Promise<SearchIndex>;
                                                                                                                                                                                                                                                                                            • Returns an index by it's name.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The index to retrieve.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method getIndexedDocumentsCount

                                                                                                                                                                                                                                                                                            getIndexedDocumentsCount: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: GetSearchIndexedDocumentsCountOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<number>
                                                                                                                                                                                                                                                                                            ) => Promise<number>;
                                                                                                                                                                                                                                                                                            • Returns the number of documents that have been indexed.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to return the count for.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method pauseIngest

                                                                                                                                                                                                                                                                                            pauseIngest: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: PauseSearchIngestOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                            • Pauses the ingestion of documents into an index.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to pause.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method resumeIngest

                                                                                                                                                                                                                                                                                            resumeIngest: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: ResumeSearchIngestOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                            • Resumes the ingestion of documents into an index.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to resume.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method unfreezePlan

                                                                                                                                                                                                                                                                                            unfreezePlan: (
                                                                                                                                                                                                                                                                                            indexName: string,
                                                                                                                                                                                                                                                                                            options?: UnfreezeSearchPlanOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                            • Unfreezes the indexing plan for execution of queries.

                                                                                                                                                                                                                                                                                              Parameter indexName

                                                                                                                                                                                                                                                                                              The name of the index to freeze the plan of.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            method upsertIndex

                                                                                                                                                                                                                                                                                            upsertIndex: (
                                                                                                                                                                                                                                                                                            indexDefinition: ISearchIndex,
                                                                                                                                                                                                                                                                                            options?: UpsertSearchIndexOptions,
                                                                                                                                                                                                                                                                                            callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                            ) => Promise<void>;
                                                                                                                                                                                                                                                                                            • Creates or updates an existing index.

                                                                                                                                                                                                                                                                                              Parameter indexDefinition

                                                                                                                                                                                                                                                                                              The index to update.

                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                              Optional parameters for this operation.

                                                                                                                                                                                                                                                                                              Parameter callback

                                                                                                                                                                                                                                                                                              A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                            class ScopeSpec

                                                                                                                                                                                                                                                                                            class ScopeSpec {}
                                                                                                                                                                                                                                                                                            • Contains information about a scope.

                                                                                                                                                                                                                                                                                              Management

                                                                                                                                                                                                                                                                                            property collections

                                                                                                                                                                                                                                                                                            collections: CollectionSpec[];
                                                                                                                                                                                                                                                                                            • The collections which exist in this scope.

                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                                            • The name of the scope.

                                                                                                                                                                                                                                                                                            class ScoreSearchSort

                                                                                                                                                                                                                                                                                            class ScoreSearchSort extends SearchSort {}
                                                                                                                                                                                                                                                                                            • Provides sorting for a search query by score.

                                                                                                                                                                                                                                                                                              Full Text Search

                                                                                                                                                                                                                                                                                            method descending

                                                                                                                                                                                                                                                                                            descending: (descending: boolean) => ScoreSearchSort;

                                                                                                                                                                                                                                                                                              class SearchErrorContext

                                                                                                                                                                                                                                                                                              class SearchErrorContext extends ErrorContext {}
                                                                                                                                                                                                                                                                                              • The error context information for a search query operation.

                                                                                                                                                                                                                                                                                                Error Handling

                                                                                                                                                                                                                                                                                              property http_response_body

                                                                                                                                                                                                                                                                                              http_response_body: string;
                                                                                                                                                                                                                                                                                              • The http response body which was received.

                                                                                                                                                                                                                                                                                              property http_response_code

                                                                                                                                                                                                                                                                                              http_response_code: number;
                                                                                                                                                                                                                                                                                              • The http response status code which was received.

                                                                                                                                                                                                                                                                                              property index_name

                                                                                                                                                                                                                                                                                              index_name: string;
                                                                                                                                                                                                                                                                                              • The name of the index which was being operated on.

                                                                                                                                                                                                                                                                                              property parameters

                                                                                                                                                                                                                                                                                              parameters: any;
                                                                                                                                                                                                                                                                                              • A list of the parameters in use for the operation.

                                                                                                                                                                                                                                                                                              property query

                                                                                                                                                                                                                                                                                              query: any;
                                                                                                                                                                                                                                                                                              • The full query that was being executed.

                                                                                                                                                                                                                                                                                              class SearchFacet

                                                                                                                                                                                                                                                                                              class SearchFacet {}
                                                                                                                                                                                                                                                                                              • Provides the ability to specify facets for a search query.

                                                                                                                                                                                                                                                                                                Full Text Search

                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                              constructor(data: any);

                                                                                                                                                                                                                                                                                                method date

                                                                                                                                                                                                                                                                                                static date: (field: string, size: number) => DateSearchFacet;

                                                                                                                                                                                                                                                                                                  method numeric

                                                                                                                                                                                                                                                                                                  static numeric: (field: string, size: number) => NumericSearchFacet;

                                                                                                                                                                                                                                                                                                    method term

                                                                                                                                                                                                                                                                                                    static term: (field: string, size: number) => TermSearchFacet;

                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                      toJSON: () => any;

                                                                                                                                                                                                                                                                                                        class SearchIndex

                                                                                                                                                                                                                                                                                                        class SearchIndex implements ISearchIndex {}
                                                                                                                                                                                                                                                                                                        • This class is currently incomplete and must be casted to any in TypeScript to be used.

                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                        name: string;
                                                                                                                                                                                                                                                                                                        • The name of the search index.

                                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                                        params: { [key: string]: any };
                                                                                                                                                                                                                                                                                                        • Parameters to specify such as the store type and mappins.

                                                                                                                                                                                                                                                                                                        property planParams

                                                                                                                                                                                                                                                                                                        planParams: { [key: string]: any };
                                                                                                                                                                                                                                                                                                        • Plan properties such as the number of replicas and number of partitions.

                                                                                                                                                                                                                                                                                                        property sourceName

                                                                                                                                                                                                                                                                                                        sourceName: string;
                                                                                                                                                                                                                                                                                                        • Name of the source of the data (ie: the bucket name).

                                                                                                                                                                                                                                                                                                        property sourceParams

                                                                                                                                                                                                                                                                                                        sourceParams: { [key: string]: any };
                                                                                                                                                                                                                                                                                                        • Extra parameters for the source. These are usually things like advanced connection options and tuning parameters.

                                                                                                                                                                                                                                                                                                        property sourceType

                                                                                                                                                                                                                                                                                                        sourceType: string;
                                                                                                                                                                                                                                                                                                        • The type of the source (couchbase or nil).

                                                                                                                                                                                                                                                                                                        property sourceUuid

                                                                                                                                                                                                                                                                                                        sourceUuid: string;
                                                                                                                                                                                                                                                                                                        • The UUID of the data source.

                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                        type: string;
                                                                                                                                                                                                                                                                                                        • The type of index to use (fulltext-index or fulltext-alias).

                                                                                                                                                                                                                                                                                                        property uuid

                                                                                                                                                                                                                                                                                                        uuid?: string;
                                                                                                                                                                                                                                                                                                        • The UUID of the search index. Used for updates to ensure consistency.

                                                                                                                                                                                                                                                                                                        class SearchIndexManager

                                                                                                                                                                                                                                                                                                        class SearchIndexManager {}
                                                                                                                                                                                                                                                                                                        • SearchIndexManager provides an interface for managing the search indexes on the cluster.

                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                        method allowQuerying

                                                                                                                                                                                                                                                                                                        allowQuerying: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: AllowSearchQueryingOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                        • Enables querying of an index.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to enable querying for.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method analyzeDocument

                                                                                                                                                                                                                                                                                                        analyzeDocument: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        document: any,
                                                                                                                                                                                                                                                                                                        options?: AnalyzeSearchDocumentOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<any>
                                                                                                                                                                                                                                                                                                        ) => Promise<any>;
                                                                                                                                                                                                                                                                                                        • Performs analysis of a specific document by an index.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to use for the analysis.

                                                                                                                                                                                                                                                                                                          Parameter document

                                                                                                                                                                                                                                                                                                          The document to analyze.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method disallowQuerying

                                                                                                                                                                                                                                                                                                        disallowQuerying: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: DisallowSearchQueryingOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                        • Disables querying of an index.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to disable querying for.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method dropIndex

                                                                                                                                                                                                                                                                                                        dropIndex: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: DropSearchIndexOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                        • Drops an index.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to drop.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method freezePlan

                                                                                                                                                                                                                                                                                                        freezePlan: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: FreezeSearchPlanOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                        • Freezes the indexing plan for execution of queries.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to freeze the plan of.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method getAllIndexes

                                                                                                                                                                                                                                                                                                        getAllIndexes: (
                                                                                                                                                                                                                                                                                                        options?: GetAllSearchIndexesOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<SearchIndex[]>
                                                                                                                                                                                                                                                                                                        ) => Promise<SearchIndex[]>;
                                                                                                                                                                                                                                                                                                        • Returns a list of all existing indexes.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method getIndex

                                                                                                                                                                                                                                                                                                        getIndex: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: GetSearchIndexOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<SearchIndex>
                                                                                                                                                                                                                                                                                                        ) => Promise<SearchIndex>;
                                                                                                                                                                                                                                                                                                        • Returns an index by it's name.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The index to retrieve.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method getIndexedDocumentsCount

                                                                                                                                                                                                                                                                                                        getIndexedDocumentsCount: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: GetSearchIndexedDocumentsCountOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<number>
                                                                                                                                                                                                                                                                                                        ) => Promise<number>;
                                                                                                                                                                                                                                                                                                        • Returns the number of documents that have been indexed.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to return the count for.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method pauseIngest

                                                                                                                                                                                                                                                                                                        pauseIngest: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: PauseSearchIngestOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                        • Pauses the ingestion of documents into an index.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to pause.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method resumeIngest

                                                                                                                                                                                                                                                                                                        resumeIngest: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: ResumeSearchIngestOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                        • Resumes the ingestion of documents into an index.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to resume.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method unfreezePlan

                                                                                                                                                                                                                                                                                                        unfreezePlan: (
                                                                                                                                                                                                                                                                                                        indexName: string,
                                                                                                                                                                                                                                                                                                        options?: UnfreezeSearchPlanOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                        • Unfreezes the indexing plan for execution of queries.

                                                                                                                                                                                                                                                                                                          Parameter indexName

                                                                                                                                                                                                                                                                                                          The name of the index to freeze the plan of.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        method upsertIndex

                                                                                                                                                                                                                                                                                                        upsertIndex: (
                                                                                                                                                                                                                                                                                                        indexDefinition: ISearchIndex,
                                                                                                                                                                                                                                                                                                        options?: UpsertSearchIndexOptions,
                                                                                                                                                                                                                                                                                                        callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                        ) => Promise<void>;
                                                                                                                                                                                                                                                                                                        • Creates or updates an existing index.

                                                                                                                                                                                                                                                                                                          Parameter indexDefinition

                                                                                                                                                                                                                                                                                                          The index to update.

                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                          Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                          Parameter callback

                                                                                                                                                                                                                                                                                                          A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                        class SearchMetaData

                                                                                                                                                                                                                                                                                                        class SearchMetaData {}
                                                                                                                                                                                                                                                                                                        • SearchMetaData represents the meta-data available from a search query. This class is currently incomplete and must be casted to any in TypeScript to be used.

                                                                                                                                                                                                                                                                                                          Full Text Search

                                                                                                                                                                                                                                                                                                        class SearchQuery

                                                                                                                                                                                                                                                                                                        class SearchQuery {}
                                                                                                                                                                                                                                                                                                        • Provides the ability to specify the query for a search query.

                                                                                                                                                                                                                                                                                                          Full Text Search

                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                        constructor(data: any);

                                                                                                                                                                                                                                                                                                          method boolean

                                                                                                                                                                                                                                                                                                          static boolean: () => BooleanSearchQuery;

                                                                                                                                                                                                                                                                                                            method booleanField

                                                                                                                                                                                                                                                                                                            static booleanField: (val: boolean) => BooleanFieldSearchQuery;

                                                                                                                                                                                                                                                                                                              method conjuncts

                                                                                                                                                                                                                                                                                                              static conjuncts: {
                                                                                                                                                                                                                                                                                                              (queries: SearchQuery[]): ConjunctionSearchQuery;
                                                                                                                                                                                                                                                                                                              (...queries: SearchQuery[]): ConjunctionSearchQuery;
                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                              • Creates a ConjunctionSearchQuery from a set of other SearchQuery's.

                                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                                Use the multi-argument overload instead.

                                                                                                                                                                                                                                                                                                              • Creates a ConjunctionSearchQuery from a set of other SearchQuery's.

                                                                                                                                                                                                                                                                                                              method dateRange

                                                                                                                                                                                                                                                                                                              static dateRange: () => DateRangeSearchQuery;

                                                                                                                                                                                                                                                                                                                method disjuncts

                                                                                                                                                                                                                                                                                                                static disjuncts: {
                                                                                                                                                                                                                                                                                                                (queries: SearchQuery[]): DisjunctionSearchQuery;
                                                                                                                                                                                                                                                                                                                (...queries: SearchQuery[]): DisjunctionSearchQuery;
                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                • Creates a DisjunctionSearchQuery from a set of other SearchQuery's.

                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                  Use the multi-argument overload instead.

                                                                                                                                                                                                                                                                                                                • Creates a DisjunctionSearchQuery from a set of other SearchQuery's.

                                                                                                                                                                                                                                                                                                                method docIds

                                                                                                                                                                                                                                                                                                                static docIds: {
                                                                                                                                                                                                                                                                                                                (queries: string[]): DocIdSearchQuery;
                                                                                                                                                                                                                                                                                                                (...queries: string[]): DocIdSearchQuery;
                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                • Creates a DocIdSearchQuery from a set of document-ids.

                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                  Use the multi-argument overload instead.

                                                                                                                                                                                                                                                                                                                • Creates a DocIdSearchQuery from a set of document-ids.

                                                                                                                                                                                                                                                                                                                method geoBoundingBox

                                                                                                                                                                                                                                                                                                                static geoBoundingBox: (
                                                                                                                                                                                                                                                                                                                tl_lon: number,
                                                                                                                                                                                                                                                                                                                tl_lat: number,
                                                                                                                                                                                                                                                                                                                br_lon: number,
                                                                                                                                                                                                                                                                                                                br_lat: number
                                                                                                                                                                                                                                                                                                                ) => GeoBoundingBoxSearchQuery;

                                                                                                                                                                                                                                                                                                                  method geoDistance

                                                                                                                                                                                                                                                                                                                  static geoDistance: (
                                                                                                                                                                                                                                                                                                                  lon: number,
                                                                                                                                                                                                                                                                                                                  lat: number,
                                                                                                                                                                                                                                                                                                                  distance: number
                                                                                                                                                                                                                                                                                                                  ) => GeoDistanceSearchQuery;

                                                                                                                                                                                                                                                                                                                    method geoPolygon

                                                                                                                                                                                                                                                                                                                    static geoPolygon: (points: GeoPoint[]) => GeoPolygonSearchQuery;

                                                                                                                                                                                                                                                                                                                      method match

                                                                                                                                                                                                                                                                                                                      static match: (match: string) => MatchSearchQuery;

                                                                                                                                                                                                                                                                                                                        method matchAll

                                                                                                                                                                                                                                                                                                                        static matchAll: () => MatchAllSearchQuery;

                                                                                                                                                                                                                                                                                                                          method matchNone

                                                                                                                                                                                                                                                                                                                          static matchNone: () => MatchNoneSearchQuery;

                                                                                                                                                                                                                                                                                                                            method matchPhrase

                                                                                                                                                                                                                                                                                                                            static matchPhrase: (phrase: string) => MatchPhraseSearchQuery;

                                                                                                                                                                                                                                                                                                                              method numericRange

                                                                                                                                                                                                                                                                                                                              static numericRange: () => NumericRangeSearchQuery;

                                                                                                                                                                                                                                                                                                                                method phrase

                                                                                                                                                                                                                                                                                                                                static phrase: (terms: string[]) => PhraseSearchQuery;

                                                                                                                                                                                                                                                                                                                                  method prefix

                                                                                                                                                                                                                                                                                                                                  static prefix: (prefix: string) => PrefixSearchQuery;

                                                                                                                                                                                                                                                                                                                                    method queryString

                                                                                                                                                                                                                                                                                                                                    static queryString: (query: string) => QueryStringSearchQuery;

                                                                                                                                                                                                                                                                                                                                      method regexp

                                                                                                                                                                                                                                                                                                                                      static regexp: (regexp: string) => RegexpSearchQuery;

                                                                                                                                                                                                                                                                                                                                        method term

                                                                                                                                                                                                                                                                                                                                        static term: (term: string) => TermSearchQuery;

                                                                                                                                                                                                                                                                                                                                          method wildcard

                                                                                                                                                                                                                                                                                                                                          static wildcard: (wildcard: string) => WildcardSearchQuery;

                                                                                                                                                                                                                                                                                                                                            class SearchRequest

                                                                                                                                                                                                                                                                                                                                            class SearchRequest {}
                                                                                                                                                                                                                                                                                                                                            • Represents a search query and/or vector search to execute via the Couchbase Full Text Search (FTS) service.

                                                                                                                                                                                                                                                                                                                                              Full Text Search

                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                            constructor(query: SearchQuery | VectorSearch);

                                                                                                                                                                                                                                                                                                                                              method create

                                                                                                                                                                                                                                                                                                                                              static create: (query: SearchQuery | VectorSearch) => SearchRequest;
                                                                                                                                                                                                                                                                                                                                              • Creates a search request.

                                                                                                                                                                                                                                                                                                                                                Parameter query

                                                                                                                                                                                                                                                                                                                                                Either a SearchQuery or VectorSearch to add to the search request.

                                                                                                                                                                                                                                                                                                                                              method withSearchQuery

                                                                                                                                                                                                                                                                                                                                              withSearchQuery: (query: SearchQuery) => SearchRequest;
                                                                                                                                                                                                                                                                                                                                              • Adds a search query to the request if the request does not already have a search query.

                                                                                                                                                                                                                                                                                                                                                Parameter query

                                                                                                                                                                                                                                                                                                                                                A SearchQuery to add to the request.

                                                                                                                                                                                                                                                                                                                                              method withVectorSearch

                                                                                                                                                                                                                                                                                                                                              withVectorSearch: (search: VectorSearch) => SearchRequest;
                                                                                                                                                                                                                                                                                                                                              • Adds a vector search to the request if the request does not already have a vector search.

                                                                                                                                                                                                                                                                                                                                                Parameter search

                                                                                                                                                                                                                                                                                                                                                A VectorSearch to add to the request.

                                                                                                                                                                                                                                                                                                                                              class SearchResult

                                                                                                                                                                                                                                                                                                                                              class SearchResult {}
                                                                                                                                                                                                                                                                                                                                              • Contains the results of a search query.

                                                                                                                                                                                                                                                                                                                                                Full Text Search

                                                                                                                                                                                                                                                                                                                                              property meta

                                                                                                                                                                                                                                                                                                                                              meta: SearchMetaData;
                                                                                                                                                                                                                                                                                                                                              • The meta-data which has been returned by the query.

                                                                                                                                                                                                                                                                                                                                              property rows

                                                                                                                                                                                                                                                                                                                                              rows: any[];
                                                                                                                                                                                                                                                                                                                                              • The rows which have been returned by the query.

                                                                                                                                                                                                                                                                                                                                              class SearchRow

                                                                                                                                                                                                                                                                                                                                              class SearchRow {}
                                                                                                                                                                                                                                                                                                                                              • SearchRow represents the data available from a row of a search query. This class is currently incomplete and must be casted to any in TypeScript to be used.

                                                                                                                                                                                                                                                                                                                                                Full Text Search

                                                                                                                                                                                                                                                                                                                                              class SearchSort

                                                                                                                                                                                                                                                                                                                                              class SearchSort {}
                                                                                                                                                                                                                                                                                                                                              • Provides the ability to specify sorting for a search query.

                                                                                                                                                                                                                                                                                                                                                Full Text Search

                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                              constructor(data: any);

                                                                                                                                                                                                                                                                                                                                                method field

                                                                                                                                                                                                                                                                                                                                                static field: (field: string) => FieldSearchSort;

                                                                                                                                                                                                                                                                                                                                                  method geoDistance

                                                                                                                                                                                                                                                                                                                                                  static geoDistance: (
                                                                                                                                                                                                                                                                                                                                                  field: string,
                                                                                                                                                                                                                                                                                                                                                  lat: number,
                                                                                                                                                                                                                                                                                                                                                  lon: number
                                                                                                                                                                                                                                                                                                                                                  ) => GeoDistanceSearchSort;

                                                                                                                                                                                                                                                                                                                                                    method id

                                                                                                                                                                                                                                                                                                                                                    static id: () => IdSearchSort;

                                                                                                                                                                                                                                                                                                                                                      method score

                                                                                                                                                                                                                                                                                                                                                      static score: () => ScoreSearchSort;

                                                                                                                                                                                                                                                                                                                                                        method toJSON

                                                                                                                                                                                                                                                                                                                                                        toJSON: () => any;

                                                                                                                                                                                                                                                                                                                                                          class ServiceNotAvailableError

                                                                                                                                                                                                                                                                                                                                                          class ServiceNotAvailableError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                          • Indicates that the operation requires a service which was not available. For instance, attempting to perform a query without the query service being enabled.

                                                                                                                                                                                                                                                                                                                                                            Error Handling

                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                            class StreamableReplicasPromise

                                                                                                                                                                                                                                                                                                                                                            class StreamableReplicasPromise<T, TRep> extends StreamablePromise<T> {}
                                                                                                                                                                                                                                                                                                                                                            • Provides the ability to be used as both a promise, or an event emitter. Enabling an application to easily retrieve all results using async/await, while also enabling streaming of results by listening for the replica event.

                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                            constructor(fn: (replicas: TRep[]) => T);

                                                                                                                                                                                                                                                                                                                                                              class StreamableRowPromise

                                                                                                                                                                                                                                                                                                                                                              class StreamableRowPromise<T, TRow, TMeta> extends StreamablePromise<T> {}
                                                                                                                                                                                                                                                                                                                                                              • Provides the ability to be used as both a promise, or an event emitter. Enabling an application to easily retrieve all results using async/await, while also enabling streaming of results by listening for the row and meta events.

                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                              constructor(fn: (rows: TRow[], meta: TMeta) => T);

                                                                                                                                                                                                                                                                                                                                                                class StreamableScanPromise

                                                                                                                                                                                                                                                                                                                                                                class StreamableScanPromise<T, TRes> extends StreamablePromise<T> {}

                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                  constructor(fn: (results: TRes[]) => T);

                                                                                                                                                                                                                                                                                                                                                                    property cancelRequested

                                                                                                                                                                                                                                                                                                                                                                    readonly cancelRequested: boolean;

                                                                                                                                                                                                                                                                                                                                                                      method cancelStreaming

                                                                                                                                                                                                                                                                                                                                                                      cancelStreaming: () => void;

                                                                                                                                                                                                                                                                                                                                                                        class TemporaryFailureError

                                                                                                                                                                                                                                                                                                                                                                        class TemporaryFailureError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                        • Indicates that a temporary failure occured, attempting the same operation in the future may succeed.

                                                                                                                                                                                                                                                                                                                                                                          Error Handling

                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                          class TermSearchFacet

                                                                                                                                                                                                                                                                                                                                                                          class TermSearchFacet extends SearchFacet {}
                                                                                                                                                                                                                                                                                                                                                                          • Provides ability to request a term facet.

                                                                                                                                                                                                                                                                                                                                                                            Full Text Search

                                                                                                                                                                                                                                                                                                                                                                          class TermSearchQuery

                                                                                                                                                                                                                                                                                                                                                                          class TermSearchQuery extends SearchQuery {}
                                                                                                                                                                                                                                                                                                                                                                          • Represents a term search query.

                                                                                                                                                                                                                                                                                                                                                                            Full Text Search

                                                                                                                                                                                                                                                                                                                                                                          method boost

                                                                                                                                                                                                                                                                                                                                                                          boost: (boost: number) => TermSearchQuery;

                                                                                                                                                                                                                                                                                                                                                                            method field

                                                                                                                                                                                                                                                                                                                                                                            field: (field: string) => TermSearchQuery;

                                                                                                                                                                                                                                                                                                                                                                              method fuzziness

                                                                                                                                                                                                                                                                                                                                                                              fuzziness: (fuzziness: number) => TermSearchQuery;

                                                                                                                                                                                                                                                                                                                                                                                method prefixLength

                                                                                                                                                                                                                                                                                                                                                                                prefixLength: (prefixLength: number) => TermSearchQuery;

                                                                                                                                                                                                                                                                                                                                                                                  class TimeoutError

                                                                                                                                                                                                                                                                                                                                                                                  class TimeoutError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                  • Indicates that the operation timed out.

                                                                                                                                                                                                                                                                                                                                                                                    Error Handling

                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                    class TransactionAttemptContext

                                                                                                                                                                                                                                                                                                                                                                                    class TransactionAttemptContext {}
                                                                                                                                                                                                                                                                                                                                                                                    • Provides an interface to preform transactional operations in a transaction.

                                                                                                                                                                                                                                                                                                                                                                                      Transactions

                                                                                                                                                                                                                                                                                                                                                                                    method get

                                                                                                                                                                                                                                                                                                                                                                                    get: (
                                                                                                                                                                                                                                                                                                                                                                                    collection: Collection,
                                                                                                                                                                                                                                                                                                                                                                                    key: string,
                                                                                                                                                                                                                                                                                                                                                                                    options?: TransactionGetOptions
                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<TransactionGetResult>;
                                                                                                                                                                                                                                                                                                                                                                                    • Retrieves the value of a document from the collection.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter collection

                                                                                                                                                                                                                                                                                                                                                                                      The collection the document lives in.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter key

                                                                                                                                                                                                                                                                                                                                                                                      The document key to retrieve.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                      Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                    method insert

                                                                                                                                                                                                                                                                                                                                                                                    insert: (
                                                                                                                                                                                                                                                                                                                                                                                    collection: Collection,
                                                                                                                                                                                                                                                                                                                                                                                    key: string,
                                                                                                                                                                                                                                                                                                                                                                                    content: any,
                                                                                                                                                                                                                                                                                                                                                                                    options?: TransactionInsertOptions
                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<TransactionGetResult>;
                                                                                                                                                                                                                                                                                                                                                                                    • Inserts a new document to the collection, failing if the document already exists.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter collection

                                                                                                                                                                                                                                                                                                                                                                                      The collection the document lives in.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter key

                                                                                                                                                                                                                                                                                                                                                                                      The document key to insert.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter content

                                                                                                                                                                                                                                                                                                                                                                                      The document content to insert.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                      Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                    method query

                                                                                                                                                                                                                                                                                                                                                                                    query: <TRow = any>(
                                                                                                                                                                                                                                                                                                                                                                                    statement: string,
                                                                                                                                                                                                                                                                                                                                                                                    options?: TransactionQueryOptions
                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<TransactionQueryResult<TRow>>;
                                                                                                                                                                                                                                                                                                                                                                                    • Executes a query in the context of this transaction.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter statement

                                                                                                                                                                                                                                                                                                                                                                                      The statement to execute.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                      Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                    method remove

                                                                                                                                                                                                                                                                                                                                                                                    remove: (doc: TransactionGetResult) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                    • Removes a document from a collection.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter doc

                                                                                                                                                                                                                                                                                                                                                                                      The document to remove.

                                                                                                                                                                                                                                                                                                                                                                                    method replace

                                                                                                                                                                                                                                                                                                                                                                                    replace: (
                                                                                                                                                                                                                                                                                                                                                                                    doc: TransactionGetResult,
                                                                                                                                                                                                                                                                                                                                                                                    content: any,
                                                                                                                                                                                                                                                                                                                                                                                    options?: TransactionReplaceOptions
                                                                                                                                                                                                                                                                                                                                                                                    ) => Promise<TransactionGetResult>;
                                                                                                                                                                                                                                                                                                                                                                                    • Replaces a document in a collection.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter doc

                                                                                                                                                                                                                                                                                                                                                                                      The document to replace.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter content

                                                                                                                                                                                                                                                                                                                                                                                      The document content to insert.

                                                                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                                                                      Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                    class TransactionCommitAmbiguousError

                                                                                                                                                                                                                                                                                                                                                                                    class TransactionCommitAmbiguousError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                    • Indicates the state of a transaction ended as ambiguous and may or may not have committed successfully.

                                                                                                                                                                                                                                                                                                                                                                                      Error Handling

                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                    constructor(cause?: Error);

                                                                                                                                                                                                                                                                                                                                                                                      class TransactionExpiredError

                                                                                                                                                                                                                                                                                                                                                                                      class TransactionExpiredError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                      • Indicates a transaction failed to complete due to expiring.

                                                                                                                                                                                                                                                                                                                                                                                        Error Handling

                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                      constructor(cause?: Error);

                                                                                                                                                                                                                                                                                                                                                                                        class TransactionFailedError

                                                                                                                                                                                                                                                                                                                                                                                        class TransactionFailedError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                        • Indicates a transaction failed to complete.

                                                                                                                                                                                                                                                                                                                                                                                          Error Handling

                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                          class TransactionGetResult

                                                                                                                                                                                                                                                                                                                                                                                          class TransactionGetResult {}
                                                                                                                                                                                                                                                                                                                                                                                          • Contains the results of a transactional Get operation.

                                                                                                                                                                                                                                                                                                                                                                                            Transactions

                                                                                                                                                                                                                                                                                                                                                                                          property cas

                                                                                                                                                                                                                                                                                                                                                                                          cas: Cas;
                                                                                                                                                                                                                                                                                                                                                                                          • The CAS of the document.

                                                                                                                                                                                                                                                                                                                                                                                          property content

                                                                                                                                                                                                                                                                                                                                                                                          content: any;
                                                                                                                                                                                                                                                                                                                                                                                          • The content of the document.

                                                                                                                                                                                                                                                                                                                                                                                          property id

                                                                                                                                                                                                                                                                                                                                                                                          id: DocumentId;
                                                                                                                                                                                                                                                                                                                                                                                          • The id of the document.

                                                                                                                                                                                                                                                                                                                                                                                          class TransactionOperationFailedError

                                                                                                                                                                                                                                                                                                                                                                                          class TransactionOperationFailedError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                          • Indicates a transaction operation failed to complete.

                                                                                                                                                                                                                                                                                                                                                                                            Error Handling

                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                            class TransactionQueryResult

                                                                                                                                                                                                                                                                                                                                                                                            class TransactionQueryResult<TRow = any> {}
                                                                                                                                                                                                                                                                                                                                                                                            • Contains the results of a transactional Query operation.

                                                                                                                                                                                                                                                                                                                                                                                              Transactions

                                                                                                                                                                                                                                                                                                                                                                                            property meta

                                                                                                                                                                                                                                                                                                                                                                                            meta: QueryMetaData;
                                                                                                                                                                                                                                                                                                                                                                                            • The meta-data which has been returned by the query.

                                                                                                                                                                                                                                                                                                                                                                                            property rows

                                                                                                                                                                                                                                                                                                                                                                                            rows: TRow[];
                                                                                                                                                                                                                                                                                                                                                                                            • The rows which have been returned by the query.

                                                                                                                                                                                                                                                                                                                                                                                            class TransactionResult

                                                                                                                                                                                                                                                                                                                                                                                            class TransactionResult {}
                                                                                                                                                                                                                                                                                                                                                                                            • Contains the results of a Transaction.

                                                                                                                                                                                                                                                                                                                                                                                              Transactions

                                                                                                                                                                                                                                                                                                                                                                                            property transactionId

                                                                                                                                                                                                                                                                                                                                                                                            transactionId: string;
                                                                                                                                                                                                                                                                                                                                                                                            • The ID of the completed transaction.

                                                                                                                                                                                                                                                                                                                                                                                            property unstagingComplete

                                                                                                                                                                                                                                                                                                                                                                                            unstagingComplete: boolean;
                                                                                                                                                                                                                                                                                                                                                                                            • Whether all documents were successfully unstaged and are now available for non-transactional operations to see.

                                                                                                                                                                                                                                                                                                                                                                                            class Transactions

                                                                                                                                                                                                                                                                                                                                                                                            class Transactions {}
                                                                                                                                                                                                                                                                                                                                                                                            • Provides an interface to access transactions.

                                                                                                                                                                                                                                                                                                                                                                                              Transactions

                                                                                                                                                                                                                                                                                                                                                                                            method run

                                                                                                                                                                                                                                                                                                                                                                                            run: (
                                                                                                                                                                                                                                                                                                                                                                                            logicFn: (attempt: TransactionAttemptContext) => Promise<void>,
                                                                                                                                                                                                                                                                                                                                                                                            config?: TransactionOptions
                                                                                                                                                                                                                                                                                                                                                                                            ) => Promise<TransactionResult>;
                                                                                                                                                                                                                                                                                                                                                                                            • Executes a transaction.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter logicFn

                                                                                                                                                                                                                                                                                                                                                                                              The transaction lambda to execute.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter config

                                                                                                                                                                                                                                                                                                                                                                                              Configuration operations for the transaction.

                                                                                                                                                                                                                                                                                                                                                                                            class UnambiguousTimeoutError

                                                                                                                                                                                                                                                                                                                                                                                            class UnambiguousTimeoutError extends TimeoutError {}
                                                                                                                                                                                                                                                                                                                                                                                            • Indicates an unambiguous timeout has occurred. The outcome of the operation is objective failure and it is known to have not completed.

                                                                                                                                                                                                                                                                                                                                                                                              Error Handling

                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                            constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                              class UnsupportedOperationError

                                                                                                                                                                                                                                                                                                                                                                                              class UnsupportedOperationError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                              • Indicates that an operation which is not supported was executed.

                                                                                                                                                                                                                                                                                                                                                                                                Error Handling

                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                              constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                                class User

                                                                                                                                                                                                                                                                                                                                                                                                class User implements IUser {}
                                                                                                                                                                                                                                                                                                                                                                                                • Contains information about a user.

                                                                                                                                                                                                                                                                                                                                                                                                  Management

                                                                                                                                                                                                                                                                                                                                                                                                property displayName

                                                                                                                                                                                                                                                                                                                                                                                                displayName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                • The display name of the user.

                                                                                                                                                                                                                                                                                                                                                                                                property groups

                                                                                                                                                                                                                                                                                                                                                                                                groups: string[];
                                                                                                                                                                                                                                                                                                                                                                                                • The groups associated with this user.

                                                                                                                                                                                                                                                                                                                                                                                                property password

                                                                                                                                                                                                                                                                                                                                                                                                password: undefined;
                                                                                                                                                                                                                                                                                                                                                                                                • This is never populated in a result returned by the server.

                                                                                                                                                                                                                                                                                                                                                                                                property roles

                                                                                                                                                                                                                                                                                                                                                                                                roles: Role[];
                                                                                                                                                                                                                                                                                                                                                                                                • The roles associates with this user.

                                                                                                                                                                                                                                                                                                                                                                                                property username

                                                                                                                                                                                                                                                                                                                                                                                                username: string;
                                                                                                                                                                                                                                                                                                                                                                                                • The username of the user.

                                                                                                                                                                                                                                                                                                                                                                                                class UserAndMetadata

                                                                                                                                                                                                                                                                                                                                                                                                class UserAndMetadata extends User {}
                                                                                                                                                                                                                                                                                                                                                                                                • Contains information about a user along with some additional meta-data about that user.

                                                                                                                                                                                                                                                                                                                                                                                                  Management

                                                                                                                                                                                                                                                                                                                                                                                                property domain

                                                                                                                                                                                                                                                                                                                                                                                                domain: string;
                                                                                                                                                                                                                                                                                                                                                                                                • The domain this user is part of.

                                                                                                                                                                                                                                                                                                                                                                                                property effectiveRoles

                                                                                                                                                                                                                                                                                                                                                                                                effectiveRoles: RoleAndOrigin[];
                                                                                                                                                                                                                                                                                                                                                                                                • The effective roles that are associated with this user.

                                                                                                                                                                                                                                                                                                                                                                                                property effectiveRolesAndOrigins

                                                                                                                                                                                                                                                                                                                                                                                                readonly effectiveRolesAndOrigins: RoleAndOrigin[];

                                                                                                                                                                                                                                                                                                                                                                                                property externalGroups

                                                                                                                                                                                                                                                                                                                                                                                                externalGroups: string[];
                                                                                                                                                                                                                                                                                                                                                                                                • The external groups that this user is associated with.

                                                                                                                                                                                                                                                                                                                                                                                                property passwordChanged

                                                                                                                                                                                                                                                                                                                                                                                                passwordChanged?: Date;
                                                                                                                                                                                                                                                                                                                                                                                                • The last time the users password was changed.

                                                                                                                                                                                                                                                                                                                                                                                                class UserExistsError

                                                                                                                                                                                                                                                                                                                                                                                                class UserExistsError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                                • Indicates that the referenced user already exists, but the operation expected it to not exist.

                                                                                                                                                                                                                                                                                                                                                                                                  Error Handling

                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                                  class UserManager

                                                                                                                                                                                                                                                                                                                                                                                                  class UserManager {}
                                                                                                                                                                                                                                                                                                                                                                                                  • UserManager is an interface which enables the management of users, groups and roles for the cluster.

                                                                                                                                                                                                                                                                                                                                                                                                    Management

                                                                                                                                                                                                                                                                                                                                                                                                  method changePassword

                                                                                                                                                                                                                                                                                                                                                                                                  changePassword: (
                                                                                                                                                                                                                                                                                                                                                                                                  newPassword: string,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: ChangePasswordOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Change password for the currently authenticatd user.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter newPassword

                                                                                                                                                                                                                                                                                                                                                                                                    The new password to be applied.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method dropGroup

                                                                                                                                                                                                                                                                                                                                                                                                  dropGroup: (
                                                                                                                                                                                                                                                                                                                                                                                                  groupName: string,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: DropGroupOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Drops an existing group.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter groupName

                                                                                                                                                                                                                                                                                                                                                                                                    The name of the group to drop.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method dropUser

                                                                                                                                                                                                                                                                                                                                                                                                  dropUser: (
                                                                                                                                                                                                                                                                                                                                                                                                  username: string,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: DropUserOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Drops an existing user.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter username

                                                                                                                                                                                                                                                                                                                                                                                                    The username of the user to drop.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method getAllGroups

                                                                                                                                                                                                                                                                                                                                                                                                  getAllGroups: (
                                                                                                                                                                                                                                                                                                                                                                                                  options?: GetAllGroupsOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<Group[]>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<Group[]>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a list of all existing groups.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method getAllUsers

                                                                                                                                                                                                                                                                                                                                                                                                  getAllUsers: (
                                                                                                                                                                                                                                                                                                                                                                                                  options?: GetAllUsersOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<UserAndMetadata[]>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<UserAndMetadata[]>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a list of all existing users.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method getGroup

                                                                                                                                                                                                                                                                                                                                                                                                  getGroup: (
                                                                                                                                                                                                                                                                                                                                                                                                  groupName: string,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: GetGroupOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<Group>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<Group>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a group by it's name.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter groupName

                                                                                                                                                                                                                                                                                                                                                                                                    The name of the group to retrieve.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method getRoles

                                                                                                                                                                                                                                                                                                                                                                                                  getRoles: (
                                                                                                                                                                                                                                                                                                                                                                                                  options?: GetRolesOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<Role[]>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<Role[]>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a list of roles available on the server.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method getUser

                                                                                                                                                                                                                                                                                                                                                                                                  getUser: (
                                                                                                                                                                                                                                                                                                                                                                                                  username: string,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: GetUserOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<UserAndMetadata>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<UserAndMetadata>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Returns a specific user by their username.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter username

                                                                                                                                                                                                                                                                                                                                                                                                    The username of the user to fetch.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method upsertGroup

                                                                                                                                                                                                                                                                                                                                                                                                  upsertGroup: (
                                                                                                                                                                                                                                                                                                                                                                                                  group: IGroup,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: UpsertGroupOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Creates or updates an existing group.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter group

                                                                                                                                                                                                                                                                                                                                                                                                    The group to update.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  method upsertUser

                                                                                                                                                                                                                                                                                                                                                                                                  upsertUser: (
                                                                                                                                                                                                                                                                                                                                                                                                  user: IUser,
                                                                                                                                                                                                                                                                                                                                                                                                  options?: UpsertUserOptions,
                                                                                                                                                                                                                                                                                                                                                                                                  callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                  ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                  • Creates or updates an existing user.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter user

                                                                                                                                                                                                                                                                                                                                                                                                    The user to update.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                    Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                    Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                    A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                  class UserNotFoundError

                                                                                                                                                                                                                                                                                                                                                                                                  class UserNotFoundError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                                  • Indicates that the referenced user does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                    Error Handling

                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                  constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                                    class ValueInvalidError

                                                                                                                                                                                                                                                                                                                                                                                                    class ValueInvalidError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                                    • Indicates that the value passed is invalid.

                                                                                                                                                                                                                                                                                                                                                                                                      Error Handling

                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                    constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                                      class ValueNotJsonError

                                                                                                                                                                                                                                                                                                                                                                                                      class ValueNotJsonError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                                      • Indicates that a JSON operation was attempted with non-JSON data.

                                                                                                                                                                                                                                                                                                                                                                                                        Error Handling

                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                      constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                                        class ValueTooDeepError

                                                                                                                                                                                                                                                                                                                                                                                                        class ValueTooDeepError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the document created by the operation would become too deep to operate on.

                                                                                                                                                                                                                                                                                                                                                                                                          Error Handling

                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                        constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                                          class ValueTooLargeError

                                                                                                                                                                                                                                                                                                                                                                                                          class ValueTooLargeError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                                          • Indicates that a value could not be stored as it was too large.

                                                                                                                                                                                                                                                                                                                                                                                                            Error Handling

                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                          constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                                            class VectorQuery

                                                                                                                                                                                                                                                                                                                                                                                                            class VectorQuery {}
                                                                                                                                                                                                                                                                                                                                                                                                            • Represents a vector query.

                                                                                                                                                                                                                                                                                                                                                                                                              Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                            constructor(fieldName: string, vector: string | number[]);

                                                                                                                                                                                                                                                                                                                                                                                                              method boost

                                                                                                                                                                                                                                                                                                                                                                                                              boost: (boost: number) => VectorQuery;
                                                                                                                                                                                                                                                                                                                                                                                                              • Adds boost option to vector query.

                                                                                                                                                                                                                                                                                                                                                                                                                Parameter boost

                                                                                                                                                                                                                                                                                                                                                                                                                A floating point value.

                                                                                                                                                                                                                                                                                                                                                                                                              method create

                                                                                                                                                                                                                                                                                                                                                                                                              static create: (fieldName: string, vector: number[] | string) => VectorQuery;
                                                                                                                                                                                                                                                                                                                                                                                                              • Creates a vector query.

                                                                                                                                                                                                                                                                                                                                                                                                                Parameter fieldName

                                                                                                                                                                                                                                                                                                                                                                                                                The name of the field in the JSON document that holds the vector.

                                                                                                                                                                                                                                                                                                                                                                                                                Parameter vector

                                                                                                                                                                                                                                                                                                                                                                                                                List of floating point values that represent the vector.

                                                                                                                                                                                                                                                                                                                                                                                                              method numCandidates

                                                                                                                                                                                                                                                                                                                                                                                                              numCandidates: (numCandidates: number) => VectorQuery;
                                                                                                                                                                                                                                                                                                                                                                                                              • Adds numCandidates option to vector query. Value must be >= 1.

                                                                                                                                                                                                                                                                                                                                                                                                                Parameter numCandidates

                                                                                                                                                                                                                                                                                                                                                                                                                An integer value.

                                                                                                                                                                                                                                                                                                                                                                                                              class VectorSearch

                                                                                                                                                                                                                                                                                                                                                                                                              class VectorSearch {}
                                                                                                                                                                                                                                                                                                                                                                                                              • Represents a vector search.

                                                                                                                                                                                                                                                                                                                                                                                                                Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                              constructor(queries: VectorQuery[], options?: VectorSearchOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                method fromVectorQuery

                                                                                                                                                                                                                                                                                                                                                                                                                static fromVectorQuery: (query: VectorQuery) => VectorSearch;
                                                                                                                                                                                                                                                                                                                                                                                                                • Creates a vector search from a single VectorQuery.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter query

                                                                                                                                                                                                                                                                                                                                                                                                                  A vectory query that should be a part of the vector search.

                                                                                                                                                                                                                                                                                                                                                                                                                class ViewErrorContext

                                                                                                                                                                                                                                                                                                                                                                                                                class ViewErrorContext extends ErrorContext {}
                                                                                                                                                                                                                                                                                                                                                                                                                • The error context information for a views operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Error Handling

                                                                                                                                                                                                                                                                                                                                                                                                                property design_document

                                                                                                                                                                                                                                                                                                                                                                                                                design_document: string;
                                                                                                                                                                                                                                                                                                                                                                                                                • The name of the design document that was being operated on.

                                                                                                                                                                                                                                                                                                                                                                                                                property http_response_body

                                                                                                                                                                                                                                                                                                                                                                                                                http_response_body: string;
                                                                                                                                                                                                                                                                                                                                                                                                                • The http response body which was received.

                                                                                                                                                                                                                                                                                                                                                                                                                property http_response_code

                                                                                                                                                                                                                                                                                                                                                                                                                http_response_code: number;
                                                                                                                                                                                                                                                                                                                                                                                                                • The http response status code which was received.

                                                                                                                                                                                                                                                                                                                                                                                                                property parameters

                                                                                                                                                                                                                                                                                                                                                                                                                parameters: any;
                                                                                                                                                                                                                                                                                                                                                                                                                • A list of the parameters in use for the operation.

                                                                                                                                                                                                                                                                                                                                                                                                                property view

                                                                                                                                                                                                                                                                                                                                                                                                                view: string;
                                                                                                                                                                                                                                                                                                                                                                                                                • The name of the view that was being operated on.

                                                                                                                                                                                                                                                                                                                                                                                                                class ViewIndexManager

                                                                                                                                                                                                                                                                                                                                                                                                                class ViewIndexManager {}
                                                                                                                                                                                                                                                                                                                                                                                                                • ViewIndexManager is an interface which enables the management of view indexes on the cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                  Management

                                                                                                                                                                                                                                                                                                                                                                                                                method dropDesignDocument

                                                                                                                                                                                                                                                                                                                                                                                                                dropDesignDocument: {
                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                designDocName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: DropDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                designDocName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                namespace: DesignDocumentNamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: DropDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                • Drops an existing design document.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter designDocName

                                                                                                                                                                                                                                                                                                                                                                                                                  The name of the design document to drop.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                • Drops an existing design document.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter designDocName

                                                                                                                                                                                                                                                                                                                                                                                                                  The name of the design document to drop.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter namespace

                                                                                                                                                                                                                                                                                                                                                                                                                  The DesignDocument namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                method getAllDesignDocuments

                                                                                                                                                                                                                                                                                                                                                                                                                getAllDesignDocuments: {
                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                options?: GetAllDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<DesignDocument[]>
                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<DesignDocument[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                namespace: DesignDocumentNamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: GetAllDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<DesignDocument[]>
                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<DesignDocument[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                • Returns a list of all the design documents in this bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                • Returns a list of all the design documents in this bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter namespace

                                                                                                                                                                                                                                                                                                                                                                                                                  The DesignDocument namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                method getDesignDocument

                                                                                                                                                                                                                                                                                                                                                                                                                getDesignDocument: {
                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                designDocName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: GetDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<DesignDocument>
                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<DesignDocument>;
                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                designDocName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                namespace: DesignDocumentNamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: GetDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<DesignDocument>
                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<DesignDocument>;
                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the specified design document.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter designDocName

                                                                                                                                                                                                                                                                                                                                                                                                                  The name of the design document to fetch.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                • Returns the specified design document.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter designDocName

                                                                                                                                                                                                                                                                                                                                                                                                                  The name of the design document to fetch.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter namespace

                                                                                                                                                                                                                                                                                                                                                                                                                  The DesignDocument namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                method publishDesignDocument

                                                                                                                                                                                                                                                                                                                                                                                                                publishDesignDocument: (
                                                                                                                                                                                                                                                                                                                                                                                                                designDocName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: PublishDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                                ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                • Publishes a development design document to be a production design document. It does this by fetching the design document by the passed name with dev_ appended, and then performs an upsert of the production name (no dev_) with the data which was just fetched.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter designDocName

                                                                                                                                                                                                                                                                                                                                                                                                                  The name of the design document to publish.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                method upsertDesignDocument

                                                                                                                                                                                                                                                                                                                                                                                                                upsertDesignDocument: {
                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                designDoc: DesignDocument,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: UpsertDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                designDoc: DesignDocument,
                                                                                                                                                                                                                                                                                                                                                                                                                namespace?: DesignDocumentNamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                options?: UpsertDesignDocumentOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                callback?: NodeCallback<void>
                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                • Creates or updates a design document.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter designDoc

                                                                                                                                                                                                                                                                                                                                                                                                                  The DesignDocument to upsert.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                • Creates or updates a design document.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter designDoc

                                                                                                                                                                                                                                                                                                                                                                                                                  The DesignDocument to upsert.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter namespace

                                                                                                                                                                                                                                                                                                                                                                                                                  The DesignDocument namespace.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter options

                                                                                                                                                                                                                                                                                                                                                                                                                  Optional parameters for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                  Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                  A node-style callback to be invoked after execution.

                                                                                                                                                                                                                                                                                                                                                                                                                class ViewMetaData

                                                                                                                                                                                                                                                                                                                                                                                                                class ViewMetaData {}
                                                                                                                                                                                                                                                                                                                                                                                                                • Contains the meta-data that is returend from a view query.

                                                                                                                                                                                                                                                                                                                                                                                                                  Views

                                                                                                                                                                                                                                                                                                                                                                                                                property debug

                                                                                                                                                                                                                                                                                                                                                                                                                debug?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                • Contains various pieces of debug information exposed by the view service.

                                                                                                                                                                                                                                                                                                                                                                                                                property total_rows

                                                                                                                                                                                                                                                                                                                                                                                                                readonly total_rows: number;

                                                                                                                                                                                                                                                                                                                                                                                                                property totalRows

                                                                                                                                                                                                                                                                                                                                                                                                                totalRows?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                • The total number of rows available in the index that match the query.

                                                                                                                                                                                                                                                                                                                                                                                                                class ViewNotFoundError

                                                                                                                                                                                                                                                                                                                                                                                                                class ViewNotFoundError extends CouchbaseError {}
                                                                                                                                                                                                                                                                                                                                                                                                                • Indicates that the referenced view does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                                  Error Handling

                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                constructor(cause?: Error, context?: ErrorContext);

                                                                                                                                                                                                                                                                                                                                                                                                                  class ViewResult

                                                                                                                                                                                                                                                                                                                                                                                                                  class ViewResult<TValue = any, TKey = any> {}
                                                                                                                                                                                                                                                                                                                                                                                                                  • Contains the results of a view query.

                                                                                                                                                                                                                                                                                                                                                                                                                    Views

                                                                                                                                                                                                                                                                                                                                                                                                                  property meta

                                                                                                                                                                                                                                                                                                                                                                                                                  meta: ViewMetaData;
                                                                                                                                                                                                                                                                                                                                                                                                                  • The meta-data which has been returned by the query.

                                                                                                                                                                                                                                                                                                                                                                                                                  property rows

                                                                                                                                                                                                                                                                                                                                                                                                                  rows: ViewRow<TKey, TValue>[];
                                                                                                                                                                                                                                                                                                                                                                                                                  • The rows which have been returned by the query.

                                                                                                                                                                                                                                                                                                                                                                                                                  class ViewRow

                                                                                                                                                                                                                                                                                                                                                                                                                  class ViewRow<TValue = any, TKey = any> {}
                                                                                                                                                                                                                                                                                                                                                                                                                  • Contains the contents of a single row returned by a view query.

                                                                                                                                                                                                                                                                                                                                                                                                                    Views

                                                                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                                                                  id?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                  • The id for this row.

                                                                                                                                                                                                                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                                                                                                                                                                                                                  key?: {};
                                                                                                                                                                                                                                                                                                                                                                                                                  • The key for this row.

                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                  value: {};
                                                                                                                                                                                                                                                                                                                                                                                                                  • The value for this row.

                                                                                                                                                                                                                                                                                                                                                                                                                  class WildcardSearchQuery

                                                                                                                                                                                                                                                                                                                                                                                                                  class WildcardSearchQuery extends SearchQuery {}
                                                                                                                                                                                                                                                                                                                                                                                                                  • Represents a wildcard search query.

                                                                                                                                                                                                                                                                                                                                                                                                                    Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                                  method boost

                                                                                                                                                                                                                                                                                                                                                                                                                  boost: (boost: number) => WildcardSearchQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                    method field

                                                                                                                                                                                                                                                                                                                                                                                                                    field: (field: string) => WildcardSearchQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                      Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                      interface AllowSearchQueryingOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface AllowSearchQueryingOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface AnalyticsQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface AnalyticsQueryOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Analytics

                                                                                                                                                                                                                                                                                                                                                                                                                      property clientContextId

                                                                                                                                                                                                                                                                                                                                                                                                                      clientContextId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The returned client context id for this query.

                                                                                                                                                                                                                                                                                                                                                                                                                      property parameters

                                                                                                                                                                                                                                                                                                                                                                                                                      parameters?:
                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                      | any[];
                                                                                                                                                                                                                                                                                                                                                                                                                      • Values to be used for the placeholders within the query.

                                                                                                                                                                                                                                                                                                                                                                                                                      property priority

                                                                                                                                                                                                                                                                                                                                                                                                                      priority?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Indicates whether this query should be executed with a specific priority level.

                                                                                                                                                                                                                                                                                                                                                                                                                      property queryContext

                                                                                                                                                                                                                                                                                                                                                                                                                      queryContext?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the context within which this query should be executed. This can be scoped to a scope or a collection within the dataset.

                                                                                                                                                                                                                                                                                                                                                                                                                      property raw

                                                                                                                                                                                                                                                                                                                                                                                                                      raw?: {
                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies any additional parameters which should be passed to the query engine when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                      property readOnly

                                                                                                                                                                                                                                                                                                                                                                                                                      readOnly?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Indicates whether this query should be executed in read-only mode.

                                                                                                                                                                                                                                                                                                                                                                                                                      property scanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                      scanConsistency?: AnalyticsScanConsistency;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the consistency requirements when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                        • AnalyticsScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface AnalyzeSearchDocumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface AnalyzeSearchDocumentOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface AppendOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface AppendOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface BuildQueryIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface BuildQueryIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property collectionName

                                                                                                                                                                                                                                                                                                                                                                                                                      collectionName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property scopeName

                                                                                                                                                                                                                                                                                                                                                                                                                      scopeName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface Cas

                                                                                                                                                                                                                                                                                                                                                                                                                      interface Cas {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • CAS represents an opaque value which can be used to compare documents to determine if a change has occurred.

                                                                                                                                                                                                                                                                                                                                                                                                                        Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                      toJSON: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Generates a JSON representation of this CAS.

                                                                                                                                                                                                                                                                                                                                                                                                                      method toString

                                                                                                                                                                                                                                                                                                                                                                                                                      toString: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Generates a string representation of this CAS.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ChangePasswordOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ChangePasswordOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConnectAnalyticsLinkOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConnectAnalyticsLinkOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverseName

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverseName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the dataverse the link belongs to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property force

                                                                                                                                                                                                                                                                                                                                                                                                                      force?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should attempt to force the link connection.

                                                                                                                                                                                                                                                                                                                                                                                                                      property linkName

                                                                                                                                                                                                                                                                                                                                                                                                                      linkName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the link to connect.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConnectOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ConnectOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the options which can be specified when connecting to a cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                        Core

                                                                                                                                                                                                                                                                                                                                                                                                                      property authenticator

                                                                                                                                                                                                                                                                                                                                                                                                                      authenticator?: Authenticator;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies a specific authenticator to use when connecting to the cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                      property configProfile

                                                                                                                                                                                                                                                                                                                                                                                                                      configProfile?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Applies the specified ConfigProfile options to the cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                        Volatile: This API is subject to change at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                      property dnsConfig

                                                                                                                                                                                                                                                                                                                                                                                                                      dnsConfig?: DnsConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the DNS config for connections of this cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                        Volatile: This API is subject to change at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                      property password

                                                                                                                                                                                                                                                                                                                                                                                                                      password?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies a password to be used in concert with username for authentication.

                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                        • ConnectOptions.username

                                                                                                                                                                                                                                                                                                                                                                                                                      property security

                                                                                                                                                                                                                                                                                                                                                                                                                      security?: SecurityConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the security config for connections of this cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeouts

                                                                                                                                                                                                                                                                                                                                                                                                                      timeouts?: TimeoutConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the default timeouts for various operations performed by the SDK.

                                                                                                                                                                                                                                                                                                                                                                                                                      property transactions

                                                                                                                                                                                                                                                                                                                                                                                                                      transactions?: TransactionsConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the options for transactions.

                                                                                                                                                                                                                                                                                                                                                                                                                      property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                      transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the default transcoder to use when encoding or decoding document values.

                                                                                                                                                                                                                                                                                                                                                                                                                      property username

                                                                                                                                                                                                                                                                                                                                                                                                                      username?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies a username to use for an implicitly created IPasswordAuthenticator used for authentication with the cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateAnalyticsDatasetOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateAnalyticsDatasetOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property condition

                                                                                                                                                                                                                                                                                                                                                                                                                      condition?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • A conditional expression to limit the indexes scope.

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverseName

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverseName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the dataverse the dataset should belong to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the dataset already existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateAnalyticsDataverseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateAnalyticsDataverseOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the dataverse already existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateAnalyticsIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateAnalyticsIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverseName

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverseName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the dataverse the index should belong to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the dataverse not existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateAnalyticsLinkOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateAnalyticsLinkOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateBucketOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateCollectionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateCollectionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateCollectionSettings

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateCollectionSettings {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • The settings to use when creating the collection.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property history

                                                                                                                                                                                                                                                                                                                                                                                                                      history?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The history retention override setting in this collection. Only supported on Magma Buckets.

                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                      property maxExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                      maxExpiry?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreatePrimaryQueryIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreatePrimaryQueryIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property collectionName

                                                                                                                                                                                                                                                                                                                                                                                                                      collectionName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property deferred

                                                                                                                                                                                                                                                                                                                                                                                                                      deferred?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies whether this index creation should be deferred until a later point in time when they can be explicitly built together.

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the index already existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of this primary index.

                                                                                                                                                                                                                                                                                                                                                                                                                      property numReplicas

                                                                                                                                                                                                                                                                                                                                                                                                                      numReplicas?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The number of replicas of this index that should be created.

                                                                                                                                                                                                                                                                                                                                                                                                                      property scopeName

                                                                                                                                                                                                                                                                                                                                                                                                                      scopeName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateQueryIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateQueryIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property collectionName

                                                                                                                                                                                                                                                                                                                                                                                                                      collectionName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property deferred

                                                                                                                                                                                                                                                                                                                                                                                                                      deferred?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies whether this index creation should be deferred until a later point in time when they can be explicitly built together.

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the index already existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property numReplicas

                                                                                                                                                                                                                                                                                                                                                                                                                      numReplicas?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The number of replicas of this index that should be created.

                                                                                                                                                                                                                                                                                                                                                                                                                      property scopeName

                                                                                                                                                                                                                                                                                                                                                                                                                      scopeName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateScopeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface CreateScopeOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DecrementOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DecrementOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                      property expiry

                                                                                                                                                                                                                                                                                                                                                                                                                      expiry?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The expiry time that should be set for the document, expressed in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property initial

                                                                                                                                                                                                                                                                                                                                                                                                                      initial?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The initial value to use for the document if it does not already exist. Not specifying this value indicates the operation should fail if the document does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeployFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DeployFunctionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DiagnosticsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DiagnosticsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Diagnostics

                                                                                                                                                                                                                                                                                                                                                                                                                      property reportId

                                                                                                                                                                                                                                                                                                                                                                                                                      reportId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • A unique identifier for the report generated by this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DisallowSearchQueryingOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DisallowSearchQueryingOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DisconnectAnalyticsLinkOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DisconnectAnalyticsLinkOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverseName

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverseName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the dataverse the link belongs to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property linkName

                                                                                                                                                                                                                                                                                                                                                                                                                      linkName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the link to connect.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DnsConfig

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DnsConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies DNS options for the client.

                                                                                                                                                                                                                                                                                                                                                                                                                        Volatile: This API is subject to change at any time.

                                                                                                                                                                                                                                                                                                                                                                                                                        Core

                                                                                                                                                                                                                                                                                                                                                                                                                      property dnsSrvTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                      dnsSrvTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the default timeout for DNS SRV operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property nameserver

                                                                                                                                                                                                                                                                                                                                                                                                                      nameserver?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the nameserver to be used for DNS query when connecting.

                                                                                                                                                                                                                                                                                                                                                                                                                      property port

                                                                                                                                                                                                                                                                                                                                                                                                                      port?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the port to be used for DNS query when connecting.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropAnalyticsDatasetOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropAnalyticsDatasetOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverseName

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverseName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the dataverse the dataset belongs to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfNotExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfNotExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the dataset already existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropAnalyticsDataverseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropAnalyticsDataverseOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfNotExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfNotExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the dataverse not existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropAnalyticsIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropAnalyticsIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverseName

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverseName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the dataverse the index belongs to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfNotExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfNotExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the index already existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropAnalyticsLinkOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropAnalyticsLinkOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropBucketOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropCollectionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropCollectionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropDesignDocumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropDesignDocumentOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropFunctionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropGroupOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropGroupOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropPrimaryQueryIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropPrimaryQueryIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property collectionName

                                                                                                                                                                                                                                                                                                                                                                                                                      collectionName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfNotExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfNotExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the index already existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the primary index to drop.

                                                                                                                                                                                                                                                                                                                                                                                                                      property scopeName

                                                                                                                                                                                                                                                                                                                                                                                                                      scopeName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropQueryIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropQueryIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property collectionName

                                                                                                                                                                                                                                                                                                                                                                                                                      collectionName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreIfNotExists

                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreIfNotExists?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether or not the call should ignore the index already existing when determining whether the call was successful.

                                                                                                                                                                                                                                                                                                                                                                                                                      property scopeName

                                                                                                                                                                                                                                                                                                                                                                                                                      scopeName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropScopeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropScopeOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropSearchIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropSearchIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropUserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropUserOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property domainName

                                                                                                                                                                                                                                                                                                                                                                                                                      domainName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The domain to drop the user from.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface EventingFunctionUrlAuth

                                                                                                                                                                                                                                                                                                                                                                                                                      interface EventingFunctionUrlAuth {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies a type of url authentication to use.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property method

                                                                                                                                                                                                                                                                                                                                                                                                                      method: EventingFunctionUrlAuthMethod;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The method of authentication to use.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ExistsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ExistsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface FlushBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface FlushBucketOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface FreezeSearchPlanOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface FreezeSearchPlanOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface FunctionsStatusOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface FunctionsStatusOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllAnalyticsDatasetsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllAnalyticsDatasetsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllAnalyticsIndexesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllAnalyticsIndexesOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllAnalyticsLinksOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllAnalyticsLinksOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverse

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverse?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of a dataverse to filter the links list to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property linkType

                                                                                                                                                                                                                                                                                                                                                                                                                      linkType?: AnalyticsLinkType;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The type of link to filter the links list to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of a specific link to fetch.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllBucketsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllBucketsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllDesignDocumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllDesignDocumentOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllFunctionsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllFunctionsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllGroupsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllGroupsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllQueryIndexesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllQueryIndexesOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property collectionName

                                                                                                                                                                                                                                                                                                                                                                                                                      collectionName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property scopeName

                                                                                                                                                                                                                                                                                                                                                                                                                      scopeName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllReplicasOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllReplicasOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                      transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllScopesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllScopesOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllSearchIndexesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllSearchIndexesOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllUsersOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAllUsersOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property domainName

                                                                                                                                                                                                                                                                                                                                                                                                                      domainName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The domain to look in for users.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAndLockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAndLockOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                      transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAndTouchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAndTouchOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                      transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAnyReplicaOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetAnyReplicaOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                      transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetBucketOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetDesignDocumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetDesignDocumentOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetFunctionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetGroupOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetGroupOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property project

                                                                                                                                                                                                                                                                                                                                                                                                                      project?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies a list of fields within the document which should be fetched. This allows for easy retrieval of select fields without incurring the overhead of fetching the whole document.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                      transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      property withExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                      withExpiry?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Indicates that the expiry of the document should be fetched alongside the data itself.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetPendingAnalyticsMutationsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetPendingAnalyticsMutationsOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetRolesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetRolesOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSearchIndexedDocumentsCountOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSearchIndexedDocumentsCountOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSearchIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetSearchIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetUserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface GetUserOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property domainName

                                                                                                                                                                                                                                                                                                                                                                                                                      domainName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The domain to look in for the user.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IAnalyticsLink {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides a base class for specifying options for an analytics link.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverse

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverse: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The dataverse that this link belongs to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property linkType

                                                                                                                                                                                                                                                                                                                                                                                                                      linkType: AnalyticsLinkType;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies what type of analytics link this represents.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of this link.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IAzureExternalAnalyticsLink extends IAnalyticsLink {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides options for configuring an analytics remote Azure link.

                                                                                                                                                                                                                                                                                                                                                                                                                      property accountKey

                                                                                                                                                                                                                                                                                                                                                                                                                      accountKey?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The Azure blob storage account key.

                                                                                                                                                                                                                                                                                                                                                                                                                      property accountName

                                                                                                                                                                                                                                                                                                                                                                                                                      accountName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The Azure blob storage account name.

                                                                                                                                                                                                                                                                                                                                                                                                                      property blobEndpoint

                                                                                                                                                                                                                                                                                                                                                                                                                      blobEndpoint?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The Azure blob storage endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                      property connectionString

                                                                                                                                                                                                                                                                                                                                                                                                                      connectionString?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The connection string to use to connect to the external Azure store.

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverse

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverse: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The dataverse that this link belongs to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property endpointSuffix

                                                                                                                                                                                                                                                                                                                                                                                                                      endpointSuffix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The Azure blob endpoint suffix.

                                                                                                                                                                                                                                                                                                                                                                                                                      property linkType

                                                                                                                                                                                                                                                                                                                                                                                                                      linkType: AnalyticsLinkType.AzureBlobExternal;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies what type of analytics link this represents.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of this link.

                                                                                                                                                                                                                                                                                                                                                                                                                      property sharedAccessSignature

                                                                                                                                                                                                                                                                                                                                                                                                                      sharedAccessSignature?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The shared access signature to use for authentication.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IBucketSettings

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IBucketSettings {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies a number of options which can be used when updating a buckets settings.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property bucketType

                                                                                                                                                                                                                                                                                                                                                                                                                      bucketType?: BucketType | string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the type of bucket that should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                      property compressionMode

                                                                                                                                                                                                                                                                                                                                                                                                                      compressionMode?: CompressionMode | string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the compression mode that should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityMinLevel

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityMinLevel?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property ejectionMethod

                                                                                                                                                                                                                                                                                                                                                                                                                      ejectionMethod?: EvictionPolicy | string;

                                                                                                                                                                                                                                                                                                                                                                                                                      property evictionPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                      evictionPolicy?: EvictionPolicy | string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the ejection method that should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                      property flushEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                      flushEnabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether the flush operation (truncating all data in the bucket) should be enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                      property historyRetentionBytes

                                                                                                                                                                                                                                                                                                                                                                                                                      historyRetentionBytes?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the maximum history retention in bytes on all collections in this bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                      property historyRetentionCollectionDefault

                                                                                                                                                                                                                                                                                                                                                                                                                      historyRetentionCollectionDefault?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the default history retention on all collections in this bucket. Only available on Magma Buckets.

                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                      property historyRetentionDuration

                                                                                                                                                                                                                                                                                                                                                                                                                      historyRetentionDuration?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the maximum duration in seconds to be covered by the change history that is written to disk for all collections in this bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                      property maxExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                      maxExpiry?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the maximum expiry time that any document should be permitted to have. Any documents stored with an expiry configured higher than this will be forced to this number.

                                                                                                                                                                                                                                                                                                                                                                                                                      property maxTTL

                                                                                                                                                                                                                                                                                                                                                                                                                      maxTTL?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                      property minimumDurabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                      minimumDurabilityLevel?: DurabilityLevel | string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the minimum durability level that should be used for any write operations which are performed against this bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                      property numReplicas

                                                                                                                                                                                                                                                                                                                                                                                                                      numReplicas?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The number of replicas that should exist for this bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                      property ramQuotaMB

                                                                                                                                                                                                                                                                                                                                                                                                                      ramQuotaMB: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The amount of RAM which should be allocated to this bucket, expressed in megabytes.

                                                                                                                                                                                                                                                                                                                                                                                                                      property replicaIndexes

                                                                                                                                                                                                                                                                                                                                                                                                                      replicaIndexes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether the indexes on this bucket should be replicated.

                                                                                                                                                                                                                                                                                                                                                                                                                      property storageBackend

                                                                                                                                                                                                                                                                                                                                                                                                                      storageBackend?: StorageBackend | string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the storage backend to use for the bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICertificateAuthenticator

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICertificateAuthenticator {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • IPasswordAuthenticator specifies an authenticator which uses an SSL certificate and key to authenticate with the cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                        Authentication

                                                                                                                                                                                                                                                                                                                                                                                                                      property certificatePath

                                                                                                                                                                                                                                                                                                                                                                                                                      certificatePath: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The path to the certificate which should be used for certificate authentication.

                                                                                                                                                                                                                                                                                                                                                                                                                      property keyPath

                                                                                                                                                                                                                                                                                                                                                                                                                      keyPath: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The path to the key which should be used for certificate authentication.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICollectionSpec

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICollectionSpec {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides options for configuring a collection.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property history

                                                                                                                                                                                                                                                                                                                                                                                                                      history?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The history retention override setting in this collection. Only supported on Magma Buckets.

                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                      property maxExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                      maxExpiry?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the collection.

                                                                                                                                                                                                                                                                                                                                                                                                                      property scopeName

                                                                                                                                                                                                                                                                                                                                                                                                                      scopeName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the scope containing this collection.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICouchbaseAnalyticsEncryptionSettings

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICouchbaseAnalyticsEncryptionSettings {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies encryption options for an analytics remote link.

                                                                                                                                                                                                                                                                                                                                                                                                                      property certificate

                                                                                                                                                                                                                                                                                                                                                                                                                      certificate?: Buffer;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides a certificate to use for connecting when encryption level is set to full. Required when encryptionLevel is set to Full.

                                                                                                                                                                                                                                                                                                                                                                                                                      property clientCertificate

                                                                                                                                                                                                                                                                                                                                                                                                                      clientCertificate?: Buffer;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides a client certificate to use for connecting when encryption level is set to full. Cannot be set if a username/password are used.

                                                                                                                                                                                                                                                                                                                                                                                                                      property clientKey

                                                                                                                                                                                                                                                                                                                                                                                                                      clientKey?: Buffer;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides a client key to use for connecting when encryption level is set to full. Cannot be set if a username/password are used.

                                                                                                                                                                                                                                                                                                                                                                                                                      property encryptionLevel

                                                                                                                                                                                                                                                                                                                                                                                                                      encryptionLevel: AnalyticsEncryptionLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies what level of encryption should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICouchbaseRemoteAnalyticsLink extends IAnalyticsLink {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides options for configuring an analytics remote couchbase cluster link.

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverse

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverse: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The dataverse that this link belongs to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property encryption

                                                                                                                                                                                                                                                                                                                                                                                                                      encryption?: ICouchbaseAnalyticsEncryptionSettings;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The encryption settings to be used for the link.

                                                                                                                                                                                                                                                                                                                                                                                                                      property hostname

                                                                                                                                                                                                                                                                                                                                                                                                                      hostname: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The hostname of the target Couchbase cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                      property linkType

                                                                                                                                                                                                                                                                                                                                                                                                                      linkType: AnalyticsLinkType.CouchbaseRemote;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies what type of analytics link this represents.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of this link.

                                                                                                                                                                                                                                                                                                                                                                                                                      property password

                                                                                                                                                                                                                                                                                                                                                                                                                      password?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The password to use for authentication with the remote cluster. Optional if client-certificate authentication (@see ICouchbaseAnalyticsEncryptionSettings.clientCertificate) is being used.

                                                                                                                                                                                                                                                                                                                                                                                                                      property username

                                                                                                                                                                                                                                                                                                                                                                                                                      username?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The username to use for authentication with the remote cluster. Optional if client-certificate authentication (@see ICouchbaseAnalyticsEncryptionSettings.clientCertificate) is being used.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICreateBucketSettings

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ICreateBucketSettings extends IBucketSettings {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies a number of settings which can be set when creating a bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property conflictResolutionType

                                                                                                                                                                                                                                                                                                                                                                                                                      conflictResolutionType?: ConflictResolutionType | string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the conflict resolution mode to use for XDCR of this bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IGroup

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IGroup {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies information about a group.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                      description?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The description for the group.

                                                                                                                                                                                                                                                                                                                                                                                                                      property ldapGroupReference

                                                                                                                                                                                                                                                                                                                                                                                                                      ldapGroupReference?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The LDAP group that this group is associated with.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the group.

                                                                                                                                                                                                                                                                                                                                                                                                                      property roles

                                                                                                                                                                                                                                                                                                                                                                                                                      roles?: (Role | string)[];
                                                                                                                                                                                                                                                                                                                                                                                                                      • The roles which are associated with this group.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IncrementOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IncrementOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                      property expiry

                                                                                                                                                                                                                                                                                                                                                                                                                      expiry?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The expiry time that should be set for the document, expressed in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property initial

                                                                                                                                                                                                                                                                                                                                                                                                                      initial?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The initial value to use for the document if it does not already exist. Not specifying this value indicates the operation should fail if the document does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface InsertOptions

                                                                                                                                                                                                                                                                                                                                                                                                                      interface InsertOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                      property expiry

                                                                                                                                                                                                                                                                                                                                                                                                                      expiry?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the expiry time for this document, specified in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                      property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                      transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IPasswordAuthenticator

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IPasswordAuthenticator {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • IPasswordAuthenticator specifies an authenticator which uses an RBAC username and password to authenticate with the cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                        Authentication

                                                                                                                                                                                                                                                                                                                                                                                                                      property allowed_sasl_mechanisms

                                                                                                                                                                                                                                                                                                                                                                                                                      allowed_sasl_mechanisms?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                      • The sasl mechanisms to authenticate with.

                                                                                                                                                                                                                                                                                                                                                                                                                      property password

                                                                                                                                                                                                                                                                                                                                                                                                                      password: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The password to autehnticate with.

                                                                                                                                                                                                                                                                                                                                                                                                                      property username

                                                                                                                                                                                                                                                                                                                                                                                                                      username: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The username to authenticate with.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IS3ExternalAnalyticsLink extends IAnalyticsLink {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides options for configuring an analytics remote S3 link.

                                                                                                                                                                                                                                                                                                                                                                                                                      property accessKeyId

                                                                                                                                                                                                                                                                                                                                                                                                                      accessKeyId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The AWS S3 access key.

                                                                                                                                                                                                                                                                                                                                                                                                                      property dataverse

                                                                                                                                                                                                                                                                                                                                                                                                                      dataverse: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The dataverse that this link belongs to.

                                                                                                                                                                                                                                                                                                                                                                                                                      property linkType

                                                                                                                                                                                                                                                                                                                                                                                                                      linkType: AnalyticsLinkType.S3External;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies what type of analytics link this represents.

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of this link.

                                                                                                                                                                                                                                                                                                                                                                                                                      property region

                                                                                                                                                                                                                                                                                                                                                                                                                      region: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The AWS S3 region.

                                                                                                                                                                                                                                                                                                                                                                                                                      property secretAccessKey

                                                                                                                                                                                                                                                                                                                                                                                                                      secretAccessKey?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The AWS S3 secret key.

                                                                                                                                                                                                                                                                                                                                                                                                                      property serviceEndpoint

                                                                                                                                                                                                                                                                                                                                                                                                                      serviceEndpoint?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The AWS S3 service endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                      property sessionToken

                                                                                                                                                                                                                                                                                                                                                                                                                      sessionToken?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The AWS S3 token if temporary credentials are provided. Only available in Couchbase Server 7.0 and above.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ISearchIndex

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ISearchIndex {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Provides information about a search index. This class is currently incomplete and must be casted from any in TypeScript.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The name of the search index.

                                                                                                                                                                                                                                                                                                                                                                                                                      property params

                                                                                                                                                                                                                                                                                                                                                                                                                      params: {
                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                      • Parameters to specify such as the store type and mappins.

                                                                                                                                                                                                                                                                                                                                                                                                                      property planParams

                                                                                                                                                                                                                                                                                                                                                                                                                      planParams: {
                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                      • Plan properties such as the number of replicas and number of partitions.

                                                                                                                                                                                                                                                                                                                                                                                                                      property sourceName

                                                                                                                                                                                                                                                                                                                                                                                                                      sourceName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • Name of the source of the data (ie: the bucket name).

                                                                                                                                                                                                                                                                                                                                                                                                                      property sourceParams

                                                                                                                                                                                                                                                                                                                                                                                                                      sourceParams: {
                                                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                                                      • Extra parameters for the source. These are usually things like advanced connection options and tuning parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                      property sourceType

                                                                                                                                                                                                                                                                                                                                                                                                                      sourceType: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The type of the source (couchbase or nil).

                                                                                                                                                                                                                                                                                                                                                                                                                      property sourceUuid

                                                                                                                                                                                                                                                                                                                                                                                                                      sourceUuid: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The UUID of the data source.

                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                      type: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The type of index to use (fulltext-index or fulltext-alias).

                                                                                                                                                                                                                                                                                                                                                                                                                      property uuid

                                                                                                                                                                                                                                                                                                                                                                                                                      uuid?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The UUID of the search index. Used for updates to ensure consistency.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IUser

                                                                                                                                                                                                                                                                                                                                                                                                                      interface IUser {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies information about a user.

                                                                                                                                                                                                                                                                                                                                                                                                                        Management

                                                                                                                                                                                                                                                                                                                                                                                                                      property displayName

                                                                                                                                                                                                                                                                                                                                                                                                                      displayName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The display name of the user.

                                                                                                                                                                                                                                                                                                                                                                                                                      property groups

                                                                                                                                                                                                                                                                                                                                                                                                                      groups?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                      • The groups associated with this user.

                                                                                                                                                                                                                                                                                                                                                                                                                      property password

                                                                                                                                                                                                                                                                                                                                                                                                                      password?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The password for this user.

                                                                                                                                                                                                                                                                                                                                                                                                                      property roles

                                                                                                                                                                                                                                                                                                                                                                                                                      roles?: (Role | string)[];
                                                                                                                                                                                                                                                                                                                                                                                                                      • The roles associates with this user.

                                                                                                                                                                                                                                                                                                                                                                                                                      property username

                                                                                                                                                                                                                                                                                                                                                                                                                      username: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      • The username of the user.

                                                                                                                                                                                                                                                                                                                                                                                                                      interface JsonDiagnosticsReport

                                                                                                                                                                                                                                                                                                                                                                                                                      interface JsonDiagnosticsReport {}
                                                                                                                                                                                                                                                                                                                                                                                                                      • The JSON-formated output report from a diagnostics operation.

                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                        • {DiagnosticsResult} Diagnostics

                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        property sdk

                                                                                                                                                                                                                                                                                                                                                                                                                        sdk: string;

                                                                                                                                                                                                                                                                                                                                                                                                                          property services

                                                                                                                                                                                                                                                                                                                                                                                                                          services: {
                                                                                                                                                                                                                                                                                                                                                                                                                          [serviceType: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                          last_activity_us?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                          remote: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          local: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          state: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          namespace?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          details?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          }[];
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            property version

                                                                                                                                                                                                                                                                                                                                                                                                                            version: number;

                                                                                                                                                                                                                                                                                                                                                                                                                              interface JsonPingReport

                                                                                                                                                                                                                                                                                                                                                                                                                              interface JsonPingReport {}
                                                                                                                                                                                                                                                                                                                                                                                                                              • The JSON-formated output report from a ping operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                • {PingResult} Diagnostics

                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                              id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                property sdk

                                                                                                                                                                                                                                                                                                                                                                                                                                sdk: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property services

                                                                                                                                                                                                                                                                                                                                                                                                                                  services: {
                                                                                                                                                                                                                                                                                                                                                                                                                                  [serviceType: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                  latency_us: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                  remote: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  local: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  id: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  state: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  error?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                  }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                    property version

                                                                                                                                                                                                                                                                                                                                                                                                                                    version: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LookupInAllReplicasOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LookupInAllReplicasOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LookupInAnyReplicaOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LookupInAnyReplicaOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LookupInOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LookupInOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MutateInOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MutateInOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                      property cas

                                                                                                                                                                                                                                                                                                                                                                                                                                      cas?: CasInput;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • If specified, indicates that operation should be failed if the CAS has changed from this value, indicating that the document has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                                      durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property expiry

                                                                                                                                                                                                                                                                                                                                                                                                                                      expiry?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the expiry time for this document, specified in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property preserveExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                                      preserveExpiry?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies that any existing expiry on the document should be preserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property storeSemantics

                                                                                                                                                                                                                                                                                                                                                                                                                                      storeSemantics?: StoreSemantics;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies the store semantics to use for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                      timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property upsertDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                      upsertDocument?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies whether the operation should be performed with upsert semantics, creating the document if it does not already exist.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                        Use MutateInOptions.storeSemantics instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MutationToken

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MutationToken {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Represents the mutation token returned by the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                      method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                      toJSON: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generates a JSON representation of this mutation token.

                                                                                                                                                                                                                                                                                                                                                                                                                                      method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                      toString: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generates a string representation of this mutation token.

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NodeCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NodeCallback<T> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                      • Reprents a node-style callback which receives an optional error or result.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Utilities

                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                      (err: Error | null, result: T | null): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PauseFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PauseFunctionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PauseSearchIngestOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PauseSearchIngestOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PingOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PingOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Diagnostics

                                                                                                                                                                                                                                                                                                                                                                                                                                        property bucket

                                                                                                                                                                                                                                                                                                                                                                                                                                        bucket?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The name of the bucket to ping.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property reportId

                                                                                                                                                                                                                                                                                                                                                                                                                                        reportId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • A unique identifier for the report generated by this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property serviceTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                        serviceTypes?: ServiceType[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The services which should be pinged.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PrependOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PrependOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PublishDesignDocumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PublishDesignDocumentOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface QueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface QueryOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Query

                                                                                                                                                                                                                                                                                                                                                                                                                                        property adhoc

                                                                                                                                                                                                                                                                                                                                                                                                                                        adhoc?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether this is an ad-hoc query, or if it should be prepared for faster execution in the future.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property clientContextId

                                                                                                                                                                                                                                                                                                                                                                                                                                        clientContextId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The returned client context id for this query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property consistentWith

                                                                                                                                                                                                                                                                                                                                                                                                                                        consistentWith?: MutationState;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies a MutationState which the query should be consistent with.

                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                        property flexIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                        flexIndex?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether flex-indexes should be enabled. Allowing the use of full-text search from the query service.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property maxParallelism

                                                                                                                                                                                                                                                                                                                                                                                                                                        maxParallelism?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property metrics

                                                                                                                                                                                                                                                                                                                                                                                                                                        metrics?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether metrics should be captured as part of the execution of the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                        parameters?:
                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        | any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Values to be used for the placeholders within the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property pipelineBatch

                                                                                                                                                                                                                                                                                                                                                                                                                                        pipelineBatch?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property pipelineCap

                                                                                                                                                                                                                                                                                                                                                                                                                                        pipelineCap?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property preserveExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                                        preserveExpiry?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that the query should preserve the existing document expiry times when mutating documents.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property profile

                                                                                                                                                                                                                                                                                                                                                                                                                                        profile?: QueryProfileMode;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of profiling that should be used for the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property queryContext

                                                                                                                                                                                                                                                                                                                                                                                                                                        queryContext?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the context within which this query should be executed. This can be scoped to a scope or a collection within the dataset.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                        raw?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies any additional parameters which should be passed to the query engine when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property readOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                        readOnly?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that this query should be executed in read-only mode, disabling the ability for the query to make any changes to the data.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scanCap

                                                                                                                                                                                                                                                                                                                                                                                                                                        scanCap?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        scanConsistency?: QueryScanConsistency;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the consistency requirements when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                          • QueryScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scanWait

                                                                                                                                                                                                                                                                                                                                                                                                                                        scanWait?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option. Specified in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property useReplica

                                                                                                                                                                                                                                                                                                                                                                                                                                        useReplica?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether the query engine should use replica nodes for kv fetches, if the active node is down.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RemoveOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RemoveOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        property cas

                                                                                                                                                                                                                                                                                                                                                                                                                                        cas?: CasInput;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • If specified, indicates that operation should be failed if the CAS has changed from this value, indicating that the document has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ReplaceAnalyticsLinkOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ReplaceAnalyticsLinkOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ReplaceOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ReplaceOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        property cas

                                                                                                                                                                                                                                                                                                                                                                                                                                        cas?: CasInput;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • If specified, indicates that operation should be failed if the CAS has changed from this value, indicating that the document has changed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property expiry

                                                                                                                                                                                                                                                                                                                                                                                                                                        expiry?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the expiry time for this document, specified in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property preserveExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                                        preserveExpiry?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that any existing expiry on the document should be preserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                                        transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResumeFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResumeFunctionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResumeSearchIngestOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResumeSearchIngestOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ScanOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ScanOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        property batchByteLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                        batchByteLimit?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The limit applied to the number of bytes returned from the server for each partition batch.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property batchItemLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                        batchItemLimit?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The limit applied to the number of items returned from the server for each partition batch.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property concurrency

                                                                                                                                                                                                                                                                                                                                                                                                                                        concurrency?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of vBuckets which the client should scan in parallel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property consistentWith

                                                                                                                                                                                                                                                                                                                                                                                                                                        consistentWith?: MutationState;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies a MutationState which the scan should be consistent with.

                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                        property idsOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                        idsOnly?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • If the scan should only return document ids.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                                        transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SearchQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SearchQueryOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                                                        property collections

                                                                                                                                                                                                                                                                                                                                                                                                                                        collections?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the collections which should be searched as part of the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property consistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        consistency?: SearchScanConsistency;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the consistency requirements when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                          • SearchScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        property consistentWith

                                                                                                                                                                                                                                                                                                                                                                                                                                        consistentWith?: MutationState;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies a MutationState which the query should be consistent with.

                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                        property disableScoring

                                                                                                                                                                                                                                                                                                                                                                                                                                        disableScoring?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that scoring should be disabled. This improves performance but makes it impossible to sort based on how well a particular result scored.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property explain

                                                                                                                                                                                                                                                                                                                                                                                                                                        explain?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Configures whether the result should contain the execution plan for the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property facets

                                                                                                                                                                                                                                                                                                                                                                                                                                        facets?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        [name: string]: SearchFacet;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies any facets that should be included in the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property fields

                                                                                                                                                                                                                                                                                                                                                                                                                                        fields?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the list of fields which should be searched.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property highlight

                                                                                                                                                                                                                                                                                                                                                                                                                                        highlight?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        style?: HighlightStyle;
                                                                                                                                                                                                                                                                                                                                                                                                                                        fields?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies how the highlighting should behave. Specifically which mode should be used for highlighting as well as which fields should be highlighted.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property includeLocations

                                                                                                                                                                                                                                                                                                                                                                                                                                        includeLocations?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • If set to true, will include the locations in the search result.

                                                                                                                                                                                                                                                                                                                                                                                                                                          This API is subject to change without notice.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Modifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                          • @experimental

                                                                                                                                                                                                                                                                                                                                                                                                                                        property limit

                                                                                                                                                                                                                                                                                                                                                                                                                                        limit?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the limit to the number of results that should be returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property logRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                        logRequest?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Uncommitted: This API is subject to change in the future. Specifies that the search request should appear in the log.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property logResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                        logResponse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Uncommitted: This API is subject to change in the future. Specifies that the search response should appear in the log.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                        raw?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies any additional parameters which should be passed to the query engine when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property showRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                        showRequest?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that the search response should include the request JSON.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property skip

                                                                                                                                                                                                                                                                                                                                                                                                                                        skip?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of results to skip from the index before returning results.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property sort

                                                                                                                                                                                                                                                                                                                                                                                                                                        sort?: string[] | SearchSort[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies a list of fields or SearchSort's to use when sorting the result sets.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SecurityConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SecurityConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies security options for the client.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Core

                                                                                                                                                                                                                                                                                                                                                                                                                                        property trustStorePath

                                                                                                                                                                                                                                                                                                                                                                                                                                        trustStorePath?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the path to a trust store file to be used when validating the authenticity of the server when connecting over SSL.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TimeoutConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TimeoutConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the timeout options for the client.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Core

                                                                                                                                                                                                                                                                                                                                                                                                                                        property analyticsTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        analyticsTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for analytics query operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property bootstrapTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        bootstrapTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout allocated to complete bootstrap, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property connectTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        connectTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for attempting to connect to a node’s KV service via a socket, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property kvDurableTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        kvDurableTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for durable KV operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property kvTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        kvTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for KV operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property managementTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        managementTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for management operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property queryTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        queryTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for query operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property resolveTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        resolveTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout to resolve DNS name of the node to IP address, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property searchTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        searchTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for search query operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property viewTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        viewTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for views operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TouchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TouchOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionGetOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionGetOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                                        transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionInsertOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionInsertOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                                        transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionKeyspace

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionKeyspace {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the configuration options for a Transaction Keyspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property bucket

                                                                                                                                                                                                                                                                                                                                                                                                                                        bucket: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The name of the bucket for the Keyspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property collection

                                                                                                                                                                                                                                                                                                                                                                                                                                        collection?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The name of the collection for the Keyspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                        scope?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The name of the scope for the Keyspace.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the configuration options for a Transaction.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of synchronous durability level.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the timeout for the transaction.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionQueryOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property adhoc

                                                                                                                                                                                                                                                                                                                                                                                                                                        adhoc?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether this is an ad-hoc query, or if it should be prepared for faster execution in the future.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property clientContextId

                                                                                                                                                                                                                                                                                                                                                                                                                                        clientContextId?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The returned client context id for this query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property maxParallelism

                                                                                                                                                                                                                                                                                                                                                                                                                                        maxParallelism?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property metrics

                                                                                                                                                                                                                                                                                                                                                                                                                                        metrics?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether metrics should be captured as part of the execution of the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                        parameters?:
                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        | any[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Values to be used for the placeholders within the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property pipelineBatch

                                                                                                                                                                                                                                                                                                                                                                                                                                        pipelineBatch?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property pipelineCap

                                                                                                                                                                                                                                                                                                                                                                                                                                        pipelineCap?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property profile

                                                                                                                                                                                                                                                                                                                                                                                                                                        profile?: QueryProfileMode;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of profiling that should be used for the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                        raw?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies any additional parameters which should be passed to the query engine when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property readOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                        readOnly?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that this query should be executed in read-only mode, disabling the ability for the query to make any changes to the data.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scanCap

                                                                                                                                                                                                                                                                                                                                                                                                                                        scanCap?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        scanConsistency?: QueryScanConsistency;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the consistency requirements when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                          • QueryScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scanWait

                                                                                                                                                                                                                                                                                                                                                                                                                                        scanWait?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is an advanced option, see the query service reference for more information on the proper use and tuning of this option. Specified in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                        scope?: Scope;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the scope to run this query in.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionReplaceOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionReplaceOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                                        transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionsCleanupConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionsCleanupConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the configuration options for Transactions cleanup.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property cleanupWindow

                                                                                                                                                                                                                                                                                                                                                                                                                                        cleanupWindow?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the period of the cleanup system.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property disableClientAttemptCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                        disableClientAttemptCleanup?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether or not the cleanup system should clean client attempts.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property disableLostAttemptCleanup

                                                                                                                                                                                                                                                                                                                                                                                                                                        disableLostAttemptCleanup?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether or not the cleanup system should clean lost attempts.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionsConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionsConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the configuration options for Transactions.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property cleanupConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                        cleanupConfig?: TransactionsCleanupConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the configuration for the cleanup system.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of synchronous durability level.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property kvTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        kvTimeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for KV operations, specified in millseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                          Currently a no-op. CXXCBC-391: Adds support for ExtSDKIntegration which uses KV durable timeout internally.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property metadataCollection

                                                                                                                                                                                                                                                                                                                                                                                                                                        metadataCollection?: TransactionKeyspace;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the Keyspace (bucket, scope & collection) for the transaction metadata.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property queryConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                        queryConfig?: TransactionsQueryConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the configuration for queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default timeout for transactions.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionsQueryConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionsQueryConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the configuration options for Transactions queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Transactions

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        scanConsistency?: QueryScanConsistency;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the default scan consistency level for queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Transcoder {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Transcoders provide functionality for converting values passed to and from the SDK to byte arrays and flags data that can be stored to the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        method decode

                                                                                                                                                                                                                                                                                                                                                                                                                                        decode: (bytes: Buffer, flags: number) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Decodes a buffer and flags tuple back to the original type of the document.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter bytes

                                                                                                                                                                                                                                                                                                                                                                                                                                          The bytes that were previously encoded.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter flags

                                                                                                                                                                                                                                                                                                                                                                                                                                          The flags associated with the data.

                                                                                                                                                                                                                                                                                                                                                                                                                                        method encode

                                                                                                                                                                                                                                                                                                                                                                                                                                        encode: (value: any) => [Buffer, number];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Encodes the specified value, returning a buffer and flags that are stored to the server and later used for decoding.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                          The value to encode.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UndeployFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UndeployFunctionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UnfreezeSearchPlanOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UnfreezeSearchPlanOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UnlockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UnlockOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpdateBucketOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpdateBucketOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpdateCollectionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpdateCollectionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpdateCollectionSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpdateCollectionSettings {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The settings which should be updated on the collection.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property history

                                                                                                                                                                                                                                                                                                                                                                                                                                        history?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The history retention override setting in this collection. Only supported on Magma Buckets.

                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                        property maxExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                                        maxExpiry?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertDesignDocumentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertDesignDocumentOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertFunctionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertFunctionOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertGroupOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertGroupOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityLevel?: DurabilityLevel;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level of synchronous durability for this operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityPersistTo

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityPersistTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of nodes this operation should be persisted to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property durabilityReplicateTo

                                                                                                                                                                                                                                                                                                                                                                                                                                        durabilityReplicateTo?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of nodes this operation should be replicated to before it is considered successful. Note that this option is mutually exclusive of durabilityLevel.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property expiry

                                                                                                                                                                                                                                                                                                                                                                                                                                        expiry?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the expiry time for this document, specified in seconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property preserveExpiry

                                                                                                                                                                                                                                                                                                                                                                                                                                        preserveExpiry?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that any existing expiry on the document should be preserved.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property transcoder

                                                                                                                                                                                                                                                                                                                                                                                                                                        transcoder?: Transcoder;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies an explicit transcoder to use for this specific operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertSearchIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertSearchIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertUserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UpsertUserOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property domainName

                                                                                                                                                                                                                                                                                                                                                                                                                                        domainName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The domain to upsert the user within.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface VectorSearchOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface VectorSearchOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                                                        property vectorQueryCombination

                                                                                                                                                                                                                                                                                                                                                                                                                                        vectorQueryCombination?: VectorQueryCombination;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies how multiple vector queries should be combined.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ViewQueryIdRange

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ViewQueryIdRange {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the id range for a view query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Views

                                                                                                                                                                                                                                                                                                                                                                                                                                        property end

                                                                                                                                                                                                                                                                                                                                                                                                                                        end?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the last id (inclusively) that should be included in the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property start

                                                                                                                                                                                                                                                                                                                                                                                                                                        start?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the first id that should be included in the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ViewQueryKeyRange

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ViewQueryKeyRange {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the key range for a view query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Views

                                                                                                                                                                                                                                                                                                                                                                                                                                        property end

                                                                                                                                                                                                                                                                                                                                                                                                                                        end?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the last key that should be included in the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property inclusive_end

                                                                                                                                                                                                                                                                                                                                                                                                                                        inclusive_end?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property inclusiveEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                        inclusiveEnd?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether the end key should be considered inclusive or exclusive.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property start

                                                                                                                                                                                                                                                                                                                                                                                                                                        start?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the first key that should be included in the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ViewQueryOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ViewQueryOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Views

                                                                                                                                                                                                                                                                                                                                                                                                                                        property full_set

                                                                                                                                                                                                                                                                                                                                                                                                                                        full_set?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property fullSet

                                                                                                                                                                                                                                                                                                                                                                                                                                        fullSet?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates whether the query should force the entire set of document in the index to be included in the result. This is on by default for production views and off by default for development views (only a subset of results may be returned).

                                                                                                                                                                                                                                                                                                                                                                                                                                        property group

                                                                                                                                                                                                                                                                                                                                                                                                                                        group?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether the results should be grouped together.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property group_level

                                                                                                                                                                                                                                                                                                                                                                                                                                        group_level?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property groupLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        groupLevel?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the level to which results should be group.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property id_range

                                                                                                                                                                                                                                                                                                                                                                                                                                        id_range?: ViewQueryIdRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property idRange

                                                                                                                                                                                                                                                                                                                                                                                                                                        idRange?: ViewQueryIdRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies a range of ids that should be fetched from the index.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property key

                                                                                                                                                                                                                                                                                                                                                                                                                                        key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies a specific key which should be fetched from the index.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property keys

                                                                                                                                                                                                                                                                                                                                                                                                                                        keys?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies a list of keys which should be fetched from the index.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property limit

                                                                                                                                                                                                                                                                                                                                                                                                                                        limit?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the limit to the number of results that should be returned.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property namespace

                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace?: DesignDocumentNamespace;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the design document namespace to use when executing the view query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property on_error

                                                                                                                                                                                                                                                                                                                                                                                                                                        on_error?: ViewErrorMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property onError

                                                                                                                                                                                                                                                                                                                                                                                                                                        onError?: ViewErrorMode;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the error-handling behaviour that should be used when an error occurs.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property order

                                                                                                                                                                                                                                                                                                                                                                                                                                        order?: ViewOrdering;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the ordering that should be used when returning results.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property range

                                                                                                                                                                                                                                                                                                                                                                                                                                        range?: ViewQueryKeyRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies a range of keys that should be fetched from the index.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property raw

                                                                                                                                                                                                                                                                                                                                                                                                                                        raw?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies any additional parameters which should be passed to the view engine when executing the view query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property reduce

                                                                                                                                                                                                                                                                                                                                                                                                                                        reduce?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether reduction should be performed as part of the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        scanConsistency?: ViewScanConsistency;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the consistency requirements when executing the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                          • ViewScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        property skip

                                                                                                                                                                                                                                                                                                                                                                                                                                        skip?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the number of results to skip from the index before returning results.

                                                                                                                                                                                                                                                                                                                                                                                                                                        property stale

                                                                                                                                                                                                                                                                                                                                                                                                                                        stale?: string | ViewScanConsistency;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The timeout for this operation, represented in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface WatchQueryIndexOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface WatchQueryIndexOptions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        property collectionName

                                                                                                                                                                                                                                                                                                                                                                                                                                        collectionName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property scopeName

                                                                                                                                                                                                                                                                                                                                                                                                                                        scopeName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property watchPrimary

                                                                                                                                                                                                                                                                                                                                                                                                                                        watchPrimary?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies whether the primary indexes should be watched as well.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Enums

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum AnalyticsEncryptionLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum AnalyticsEncryptionLevel {
                                                                                                                                                                                                                                                                                                                                                                                                                                        None = 'none',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Half = 'half',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Full = 'full',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents what level of encryption to use for analytics remote links.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Analytics

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Full

                                                                                                                                                                                                                                                                                                                                                                                                                                        Full = 'full'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that full encryption should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Half

                                                                                                                                                                                                                                                                                                                                                                                                                                        Half = 'half'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that half encryption should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member None

                                                                                                                                                                                                                                                                                                                                                                                                                                        None = 'none'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that no encryption should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum AnalyticsLinkType

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum AnalyticsLinkType {
                                                                                                                                                                                                                                                                                                                                                                                                                                        S3External = 's3',
                                                                                                                                                                                                                                                                                                                                                                                                                                        AzureBlobExternal = 'azureblob',
                                                                                                                                                                                                                                                                                                                                                                                                                                        CouchbaseRemote = 'couchbase',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the type of an analytics link.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Analytics

                                                                                                                                                                                                                                                                                                                                                                                                                                        member AzureBlobExternal

                                                                                                                                                                                                                                                                                                                                                                                                                                        AzureBlobExternal = 'azureblob'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the link is for Azure.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member CouchbaseRemote

                                                                                                                                                                                                                                                                                                                                                                                                                                        CouchbaseRemote = 'couchbase'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the link is for a remote Couchbase cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member S3External

                                                                                                                                                                                                                                                                                                                                                                                                                                        S3External = 's3'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the link is for S3.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum AnalyticsScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum AnalyticsScanConsistency {
                                                                                                                                                                                                                                                                                                                                                                                                                                        NotBounded = 'not_bounded',
                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestPlus = 'request_plus',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various scan consistency options that are available when querying against the analytics service.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Analytics

                                                                                                                                                                                                                                                                                                                                                                                                                                        member NotBounded

                                                                                                                                                                                                                                                                                                                                                                                                                                        NotBounded = 'not_bounded'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that no specific consistency is required, this is the fastest options, but results may not include the most recent operations which have been performed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member RequestPlus

                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestPlus = 'request_plus'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the results to the query should include all operations that have occurred up until the query was started. This incurs a performance penalty of waiting for the index to catch up to the most recent operations, but provides the highest level of consistency.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum AnalyticsStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum AnalyticsStatus {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Running = 'running',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Success = 'success',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Errors = 'errors',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Completed = 'completed',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Stopped = 'stopped',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Timeout = 'timeout',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Closed = 'closed',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Fatal = 'fatal',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Aborted = 'aborted',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Unknown = 'unknown',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the status of an analytics query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Analytics

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Aborted

                                                                                                                                                                                                                                                                                                                                                                                                                                        Aborted = 'aborted'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query was aborted while executing.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Closed

                                                                                                                                                                                                                                                                                                                                                                                                                                        Closed = 'closed'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that a connection was closed during execution of the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Completed

                                                                                                                                                                                                                                                                                                                                                                                                                                        Completed = 'completed'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query completed but the outcome was unknown.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Errors

                                                                                                                                                                                                                                                                                                                                                                                                                                        Errors = 'errors'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query completed with errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Fatal

                                                                                                                                                                                                                                                                                                                                                                                                                                        Fatal = 'fatal'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query stopped with fatal errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Running

                                                                                                                                                                                                                                                                                                                                                                                                                                        Running = 'running'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the query is still running.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Stopped

                                                                                                                                                                                                                                                                                                                                                                                                                                        Stopped = 'stopped'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query was stopped.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Success

                                                                                                                                                                                                                                                                                                                                                                                                                                        Success = 'success'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query completed successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        Timeout = 'timeout'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query timed out during execution.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Unknown

                                                                                                                                                                                                                                                                                                                                                                                                                                        Unknown = 'unknown'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the status of the query is unknown.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum BucketType

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum BucketType {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Couchbase = 'membase',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Memcached = 'memcached',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Ephemeral = 'ephemeral',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the type of a bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Couchbase

                                                                                                                                                                                                                                                                                                                                                                                                                                        Couchbase = 'membase'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the bucket should be a Couchbase bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Ephemeral

                                                                                                                                                                                                                                                                                                                                                                                                                                        Ephemeral = 'ephemeral'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the bucket should be a Ephemeral bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Memcached

                                                                                                                                                                                                                                                                                                                                                                                                                                        Memcached = 'memcached'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the bucket should be a Memcached bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum CompressionMode

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum CompressionMode {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Off = 'off',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Passive = 'passive',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Active = 'active',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the compression mode that should be used for a bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Active

                                                                                                                                                                                                                                                                                                                                                                                                                                        Active = 'active'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that compression should be performed actively. Even if the client does not transmit the document in a compressed form.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Off

                                                                                                                                                                                                                                                                                                                                                                                                                                        Off = 'off'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that compression should not be used on the server.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Passive

                                                                                                                                                                                                                                                                                                                                                                                                                                        Passive = 'passive'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that compression should be used passively. That is that if the client sends data which is encrypted, it is stored on the server in its compressed form, but the server does not actively compress documents.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ConflictResolutionType

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ConflictResolutionType {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Timestamp = 'lww',
                                                                                                                                                                                                                                                                                                                                                                                                                                        SequenceNumber = 'seqno',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Custom = 'custom',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various conflict resolution modes which can be used for XDCR synchronization against a bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Custom

                                                                                                                                                                                                                                                                                                                                                                                                                                        Custom = 'custom'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that custom conflict resolution should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                          This mode is only available in Couchbase Server 7.1 with the "developer-preview" mode enabled.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Modifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                          • @experimental

                                                                                                                                                                                                                                                                                                                                                                                                                                        member SequenceNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                        SequenceNumber = 'seqno'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the seqno of the document should be used for conflict resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Timestamp

                                                                                                                                                                                                                                                                                                                                                                                                                                        Timestamp = 'lww'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that timestamps should be used for conflict resolution. The most recently modified document (according to each server, ie: time synchronization is important) is the one selected to win.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DesignDocumentNamespace

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DesignDocumentNamespace {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Development = 'development',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Production = 'production',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the namespace for the associated Design Document.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Views

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Development

                                                                                                                                                                                                                                                                                                                                                                                                                                        Development = 'development'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the Design Document namespace is within the development environment.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Production

                                                                                                                                                                                                                                                                                                                                                                                                                                        Production = 'production'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the Design Document namespace is within the producion environment.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DurabilityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum DurabilityLevel {
                                                                                                                                                                                                                                                                                                                                                                                                                                        None = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                        Majority = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                        MajorityAndPersistOnMaster = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                        PersistToMajority = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the durability level required for an operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Majority

                                                                                                                                                                                                                                                                                                                                                                                                                                        Majority = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that mutations should be replicated to a majority of the nodes in the cluster before the operation is marked as successful.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member MajorityAndPersistOnMaster

                                                                                                                                                                                                                                                                                                                                                                                                                                        MajorityAndPersistOnMaster = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that mutations should be replicated to a majority of the nodes in the cluster and persisted to the master node before the operation is marked as successful.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member None

                                                                                                                                                                                                                                                                                                                                                                                                                                        None = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that no durability is needed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member PersistToMajority

                                                                                                                                                                                                                                                                                                                                                                                                                                        PersistToMajority = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that mutations should be persisted to the majority of the nodes in the cluster before the operation is marked as successful.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EndpointState

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EndpointState {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Disconnected = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                        Connecting = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                        Connected = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                        Disconnecting = 3,
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the status of an an endpoint in a diagnostics report.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Diagnostics

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Connected

                                                                                                                                                                                                                                                                                                                                                                                                                                        Connected = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the endpoint is connected.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Connecting

                                                                                                                                                                                                                                                                                                                                                                                                                                        Connecting = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the endpoint is still connecting.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Disconnected

                                                                                                                                                                                                                                                                                                                                                                                                                                        Disconnected = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the endpoint is disconnected.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Disconnecting

                                                                                                                                                                                                                                                                                                                                                                                                                                        Disconnecting = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the endpoint is disconnecting.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionBucketAccess

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionBucketAccess {
                                                                                                                                                                                                                                                                                                                                                                                                                                        ReadOnly = 'r',
                                                                                                                                                                                                                                                                                                                                                                                                                                        ReadWrite = 'rw',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various bucket access levels for an eventing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member ReadOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                        ReadOnly = 'r'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the function can only read the associated bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member ReadWrite

                                                                                                                                                                                                                                                                                                                                                                                                                                        ReadWrite = 'rw'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the function can both read and write the associated bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionDcpBoundary

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionDcpBoundary {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Everything = 'everything',
                                                                                                                                                                                                                                                                                                                                                                                                                                        FromNow = 'from_now',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various dcp boundary options for eventing functions.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Everything

                                                                                                                                                                                                                                                                                                                                                                                                                                        Everything = 'everything'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates all documents should be processed by the function.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member FromNow

                                                                                                                                                                                                                                                                                                                                                                                                                                        FromNow = 'from_now'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that only documents modified after a function is created should be processed by the function.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionDeploymentStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionDeploymentStatus {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Deployed = 'deployed',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Undeployed = 'undeployed',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various possible deployment statuses for an eventing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Deployed

                                                                                                                                                                                                                                                                                                                                                                                                                                        Deployed = 'deployed'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the function is deployed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Undeployed

                                                                                                                                                                                                                                                                                                                                                                                                                                        Undeployed = 'undeployed'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the function has not yet been deployed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionLanguageCompatibility

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionLanguageCompatibility {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Version_6_0_0 = '6.0.0',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Version_6_5_0 = '6.5.0',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Version_6_6_2 = '6.6.2',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Version_7_2_0 = '7.2.0',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the language compatibility levels of an eventing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Version_6_0_0

                                                                                                                                                                                                                                                                                                                                                                                                                                        Version_6_0_0 = '6.0.0'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the function should run with compatibility with Couchbase Server 6.0.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Version_6_5_0

                                                                                                                                                                                                                                                                                                                                                                                                                                        Version_6_5_0 = '6.5.0'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the function should run with compatibility with Couchbase Server 6.5.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Version_6_6_2

                                                                                                                                                                                                                                                                                                                                                                                                                                        Version_6_6_2 = '6.6.2'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the function should run with compatibility with Couchbase Server 6.6.2.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Version_7_2_0

                                                                                                                                                                                                                                                                                                                                                                                                                                        Version_7_2_0 = '7.2.0'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the function should run with compatibility with Couchbase Server 7.2.0.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionLogLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionLogLevel {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Info = 'INFO',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Error = 'ERROR',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Warning = 'WARNING',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Debug = 'DEBUG',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Trace = 'TRACE',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various log levels for an eventing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Debug

                                                                                                                                                                                                                                                                                                                                                                                                                                        Debug = 'DEBUG'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates to use DEBUG level logging.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Error

                                                                                                                                                                                                                                                                                                                                                                                                                                        Error = 'ERROR'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates to use ERROR level logging.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Info

                                                                                                                                                                                                                                                                                                                                                                                                                                        Info = 'INFO'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates to use INFO level logging.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Trace

                                                                                                                                                                                                                                                                                                                                                                                                                                        Trace = 'TRACE'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates to use TRACE level logging.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Warning

                                                                                                                                                                                                                                                                                                                                                                                                                                        Warning = 'WARNING'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates to use WARNING level logging.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionProcessingStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionProcessingStatus {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Running = 'running',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Paused = 'paused',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various possible processing statuses for an eventing function.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Paused

                                                                                                                                                                                                                                                                                                                                                                                                                                        Paused = 'paused'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the eventing function is currently paused.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Running

                                                                                                                                                                                                                                                                                                                                                                                                                                        Running = 'running'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the eventing function is currently running.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionStatus {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Undeployed = 'undeployed',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Deploying = 'deploying',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Deployed = 'deployed',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Undeploying = 'undeploying',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Paused = 'paused',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Pausing = 'pausing',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the authentication method to use for a URL binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Deployed

                                                                                                                                                                                                                                                                                                                                                                                                                                        Deployed = 'deployed'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the eventing function is deployed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Deploying

                                                                                                                                                                                                                                                                                                                                                                                                                                        Deploying = 'deploying'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the eventing function is deploying.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Paused

                                                                                                                                                                                                                                                                                                                                                                                                                                        Paused = 'paused'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the eventing function is paused.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Pausing

                                                                                                                                                                                                                                                                                                                                                                                                                                        Pausing = 'pausing'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the eventing function is pausing.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Undeployed

                                                                                                                                                                                                                                                                                                                                                                                                                                        Undeployed = 'undeployed'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the eventing function is undeployed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Undeploying

                                                                                                                                                                                                                                                                                                                                                                                                                                        Undeploying = 'undeploying'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the eventing function is undeploying.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionUrlAuthMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EventingFunctionUrlAuthMethod {
                                                                                                                                                                                                                                                                                                                                                                                                                                        None = 'no-auth',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Basic = 'basic',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Digest = 'digest',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Bearer = 'bearer',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the authentication method to use for a URL binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Basic

                                                                                                                                                                                                                                                                                                                                                                                                                                        Basic = 'basic'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that Basic should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Bearer

                                                                                                                                                                                                                                                                                                                                                                                                                                        Bearer = 'bearer'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that Bearer should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Digest

                                                                                                                                                                                                                                                                                                                                                                                                                                        Digest = 'digest'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that Digest should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member None

                                                                                                                                                                                                                                                                                                                                                                                                                                        None = 'no-auth'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that no authentication should be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EvictionPolicy

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum EvictionPolicy {
                                                                                                                                                                                                                                                                                                                                                                                                                                        FullEviction = 'fullEviction',
                                                                                                                                                                                                                                                                                                                                                                                                                                        ValueOnly = 'valueOnly',
                                                                                                                                                                                                                                                                                                                                                                                                                                        NotRecentlyUsed = 'nruEviction',
                                                                                                                                                                                                                                                                                                                                                                                                                                        NoEviction = 'noEviction',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the eviction policy that should be used for a bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member FullEviction

                                                                                                                                                                                                                                                                                                                                                                                                                                        FullEviction = 'fullEviction'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that both the document meta-data and value should be evicted.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member NoEviction

                                                                                                                                                                                                                                                                                                                                                                                                                                        NoEviction = 'noEviction'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that nothing should be evicted.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member NotRecentlyUsed

                                                                                                                                                                                                                                                                                                                                                                                                                                        NotRecentlyUsed = 'nruEviction'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the least recently used documents are evicted.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member ValueOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                        ValueOnly = 'valueOnly'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that only the value of a document should be evicted.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum HighlightStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum HighlightStyle {
                                                                                                                                                                                                                                                                                                                                                                                                                                        HTML = 'html',
                                                                                                                                                                                                                                                                                                                                                                                                                                        ANSI = 'ansi',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the highlight style that should be used for matches in the results.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                                                        member ANSI

                                                                                                                                                                                                                                                                                                                                                                                                                                        ANSI = 'ansi'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that matches should be highlighted using ASCII coding in the result test.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member HTML

                                                                                                                                                                                                                                                                                                                                                                                                                                        HTML = 'html'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that matches should be highlighted using HTML tags in the result text.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum MatchOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum MatchOperator {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Or = 'or',
                                                                                                                                                                                                                                                                                                                                                                                                                                        And = 'and',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies how the individual match terms should be logically concatenated.

                                                                                                                                                                                                                                                                                                                                                                                                                                          This API is subject to change without notice. Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                                                          Modifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                          • @experimental

                                                                                                                                                                                                                                                                                                                                                                                                                                        member And

                                                                                                                                                                                                                                                                                                                                                                                                                                        And = 'and'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that individual match terms are concatenated with a logical AND.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Or

                                                                                                                                                                                                                                                                                                                                                                                                                                        Or = 'or'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies that individual match terms are concatenated with a logical OR - this is the default if not provided.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum PingState

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum PingState {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Ok = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                        Timeout = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                        Error = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the status of an an endpoint in a ping report.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Error

                                                                                                                                                                                                                                                                                                                                                                                                                                        Error = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates an error occured trying to ping the endpoint.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Ok

                                                                                                                                                                                                                                                                                                                                                                                                                                        Ok = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the endpoint was pinged successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        Timeout = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the endpoint timed out during the ping.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum QueryProfileMode

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum QueryProfileMode {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Off = 'off',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Phases = 'phases',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Timings = 'timings',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the profiling mode for a query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Query

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Off

                                                                                                                                                                                                                                                                                                                                                                                                                                        Off = 'off'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Disables the generation of profiling data.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Phases

                                                                                                                                                                                                                                                                                                                                                                                                                                        Phases = 'phases'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Enables profiling of the phases of a query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Timings

                                                                                                                                                                                                                                                                                                                                                                                                                                        Timings = 'timings'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Enables profiling of the timings of a query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum QueryScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum QueryScanConsistency {
                                                                                                                                                                                                                                                                                                                                                                                                                                        NotBounded = 'not_bounded',
                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestPlus = 'request_plus',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various scan consistency options that are available when querying against the query service.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Query

                                                                                                                                                                                                                                                                                                                                                                                                                                        member NotBounded

                                                                                                                                                                                                                                                                                                                                                                                                                                        NotBounded = 'not_bounded'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that no specific consistency is required, this is the fastest options, but results may not include the most recent operations which have been performed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member RequestPlus

                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestPlus = 'request_plus'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the results to the query should include all operations that have occurred up until the query was started. This incurs a performance penalty of waiting for the index to catch up to the most recent operations, but provides the highest level of consistency.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum QueryStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum QueryStatus {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Running = 'running',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Success = 'success',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Errors = 'errors',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Completed = 'completed',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Stopped = 'stopped',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Timeout = 'timeout',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Closed = 'closed',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Fatal = 'fatal',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Aborted = 'aborted',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Unknown = 'unknown',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the status of a query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Query

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Aborted

                                                                                                                                                                                                                                                                                                                                                                                                                                        Aborted = 'aborted'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query was aborted while executing.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Closed

                                                                                                                                                                                                                                                                                                                                                                                                                                        Closed = 'closed'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that a connection was closed during execution of the query.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Completed

                                                                                                                                                                                                                                                                                                                                                                                                                                        Completed = 'completed'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query completed but the outcome was unknown.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Errors

                                                                                                                                                                                                                                                                                                                                                                                                                                        Errors = 'errors'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query completed with errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Fatal

                                                                                                                                                                                                                                                                                                                                                                                                                                        Fatal = 'fatal'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query stopped with fatal errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Running

                                                                                                                                                                                                                                                                                                                                                                                                                                        Running = 'running'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the query is still running.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Stopped

                                                                                                                                                                                                                                                                                                                                                                                                                                        Stopped = 'stopped'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query was stopped.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Success

                                                                                                                                                                                                                                                                                                                                                                                                                                        Success = 'success'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query completed successfully.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                        Timeout = 'timeout'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the query timed out during execution.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Unknown

                                                                                                                                                                                                                                                                                                                                                                                                                                        Unknown = 'unknown'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the status of the query is unknown.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum SearchScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum SearchScanConsistency {
                                                                                                                                                                                                                                                                                                                                                                                                                                        NotBounded = 'not_bounded',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various scan consistency options that are available when querying against the query service.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                                                        member NotBounded

                                                                                                                                                                                                                                                                                                                                                                                                                                        NotBounded = 'not_bounded'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that no specific consistency is required, this is the fastest options, but results may not include the most recent operations which have been performed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ServiceType

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ServiceType {
                                                                                                                                                                                                                                                                                                                                                                                                                                        KeyValue = 'kv',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Management = 'mgmt',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Views = 'views',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Query = 'query',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Search = 'search',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Analytics = 'analytics',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Eventing = 'eventing',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various service types available.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Analytics

                                                                                                                                                                                                                                                                                                                                                                                                                                        Analytics = 'analytics'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The analytics service, responsible for analytics querying.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Eventing

                                                                                                                                                                                                                                                                                                                                                                                                                                        Eventing = 'eventing'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The eventing service, responsible for event-driven actions.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member KeyValue

                                                                                                                                                                                                                                                                                                                                                                                                                                        KeyValue = 'kv'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The key-value service, responsible for data storage.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        Management = 'mgmt'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The management service, responsible for managing the cluster.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Query

                                                                                                                                                                                                                                                                                                                                                                                                                                        Query = 'query'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The query service, responsible for N1QL querying.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Search

                                                                                                                                                                                                                                                                                                                                                                                                                                        Search = 'search'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The search service, responsible for full-text search querying.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Views

                                                                                                                                                                                                                                                                                                                                                                                                                                        Views = 'views'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • The views service, responsible for views querying.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum StorageBackend

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum StorageBackend {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Couchstore = 'couchstore',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Magma = 'magma',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the storage backend to use for a bucket.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Management

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Couchstore

                                                                                                                                                                                                                                                                                                                                                                                                                                        Couchstore = 'couchstore'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the bucket should use the Couchstore storage engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Magma

                                                                                                                                                                                                                                                                                                                                                                                                                                        Magma = 'magma'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates the bucket should use the Magma storage engine.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum StoreSemantics

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum StoreSemantics {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Replace = 0,
                                                                                                                                                                                                                                                                                                                                                                                                                                        Upsert = 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                        Insert = 2,
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the storage semantics to use for some types of operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Insert

                                                                                                                                                                                                                                                                                                                                                                                                                                        Insert = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that insert semantics should be used. This will insert the document if it does not exist, and fail the operation if the document already exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Replace

                                                                                                                                                                                                                                                                                                                                                                                                                                        Replace = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that replace semantics should be used. This will replace the document if it exists, and the operation will fail if the document does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Upsert

                                                                                                                                                                                                                                                                                                                                                                                                                                        Upsert = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that upsert semantics should be used. This will replace the document if it exists, and create it if it does not.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum VectorQueryCombination

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum VectorQueryCombination {
                                                                                                                                                                                                                                                                                                                                                                                                                                        AND = 'and',
                                                                                                                                                                                                                                                                                                                                                                                                                                        OR = 'or',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies how multiple vector searches are combined.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                                                        member AND

                                                                                                                                                                                                                                                                                                                                                                                                                                        AND = 'and'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that multiple vector queries should be combined with logical AND.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member OR

                                                                                                                                                                                                                                                                                                                                                                                                                                        OR = 'or'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that multiple vector queries should be combined with logical OR.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ViewErrorMode

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ViewErrorMode {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Continue = 'continue',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Stop = 'stop',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the error handling mode for a view query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Views

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Continue

                                                                                                                                                                                                                                                                                                                                                                                                                                        Continue = 'continue'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that if an error occurs during the execution of the view query, the query should continue to process and include any available results.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Stop

                                                                                                                                                                                                                                                                                                                                                                                                                                        Stop = 'stop'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that if an error occurs during the execution of the view query, the query should be aborted immediately rather than attempting to continue.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ViewOrdering

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ViewOrdering {
                                                                                                                                                                                                                                                                                                                                                                                                                                        Ascending = 'false',
                                                                                                                                                                                                                                                                                                                                                                                                                                        Descending = 'true',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Specifies the ordering mode of a view query.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Views

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Ascending

                                                                                                                                                                                                                                                                                                                                                                                                                                        Ascending = 'false'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that results should be returned in ascending order.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member Descending

                                                                                                                                                                                                                                                                                                                                                                                                                                        Descending = 'true'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that results should be returned in descending order.

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ViewScanConsistency

                                                                                                                                                                                                                                                                                                                                                                                                                                        enum ViewScanConsistency {
                                                                                                                                                                                                                                                                                                                                                                                                                                        NotBounded = 'ok',
                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestPlus = 'false',
                                                                                                                                                                                                                                                                                                                                                                                                                                        UpdateAfter = 'update_after',
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the various scan consistency options that are available when querying against the views service.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Views

                                                                                                                                                                                                                                                                                                                                                                                                                                        member NotBounded

                                                                                                                                                                                                                                                                                                                                                                                                                                        NotBounded = 'ok'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that no specific consistency is required, this is the fastest options, but results may not include the most recent operations which have been performed.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member RequestPlus

                                                                                                                                                                                                                                                                                                                                                                                                                                        RequestPlus = 'false'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the results to the query should include all operations that have occurred up until the query was started. This incurs a performance penalty of waiting for the index to catch up to the most recent operations, but provides the highest level of consistency.

                                                                                                                                                                                                                                                                                                                                                                                                                                        member UpdateAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                        UpdateAfter = 'update_after'
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Indicates that the results of the query should behave according to similar semantics as NotBounded, but following the execution of the query the index should begin updating such that following queries will likely include up to date data.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                        type Authenticator

                                                                                                                                                                                                                                                                                                                                                                                                                                        type Authenticator = IPasswordAuthenticator | ICertificateAuthenticator;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents any of the valid authenticators that could be passed to the SDK.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Authentication

                                                                                                                                                                                                                                                                                                                                                                                                                                        type CasInput

                                                                                                                                                                                                                                                                                                                                                                                                                                        type CasInput = Cas | string | Buffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • CasIn represents the supported types that can be provided to an operation that receive a CAS.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Key-Value

                                                                                                                                                                                                                                                                                                                                                                                                                                        type GeoPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                        type GeoPoint =
                                                                                                                                                                                                                                                                                                                                                                                                                                        | [longitude: number, latitude: number]
                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                        lon: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        lat: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                        longitude: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        latitude: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                        • GeoPoint represents a specific coordinate on earth. We support a number of different variants of geopoints being specified.

                                                                                                                                                                                                                                                                                                                                                                                                                                          Full Text Search

                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (38)

                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (25)

                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

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

                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/couchbase.

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