import { ArrayMap, BucketName, Cas, CasInput, CollectionName, CouchbaseClusterTypes, DefaultClusterTypes, DocDefMatchingKey, If, IsNever, KeyspaceDocDef, QueryContext, ScopeName } from '@cbjsdev/shared';
import { CppDocumentId, CppTransaction, CppTransactionGetMetaData, CppTransactionLinks, CppTransactions } from './binding.js';
import { Cluster } from './cluster.js';
import { CollectionKeyspace } from './clusterTypes/clusterTypes.js';
import { AnyCollection } from './clusterTypes/index.js';
import { Collection } from './collection.js';
import { DurabilityLevel } from './generaltypes.js';
import { QueryMetaData, QueryProfileMode, QueryResult, QueryScanConsistency } from './querytypes.js';
import { Transcoder } from './transcoders.js';
/**
 * Represents the path to a document.
 *
 * @category Transactions
 */
export declare class DocumentId<T extends CouchbaseClusterTypes, B extends BucketName<T>, S extends ScopeName<T, B>, C extends CollectionName<T, B, S>, const Key extends KeyspaceDocDef<T, B, S, C>['Key'] = KeyspaceDocDef<T, B, S, C>['Key']> {
    /**
     * The name of the bucket containing the document.
     */
    bucket: B;
    /**
     * The name of the scope containing the document.
     */
    scope: S;
    /**
     * The name of the collection containing the document.
     */
    collection: C;
    /**
     * The key of the document.
     */
    key: Key;
    constructor(bucket: B, scope: S, collection: C, key: Key);
}
/**
 * Specifies the configuration options for a Transaction Keyspace.
 *
 * @category Transactions
 */
export type TransactionKeyspace = {
    /**
     * The name of the bucket for the Keyspace.
     */
    bucket: string;
    /**
     * The name of the scope for the Keyspace.
     */
    scope?: string;
    /**
     * The name of the collection for the Keyspace.
     */
    collection?: string;
};
/**
 * Represents the mode of the Transactional GetMulti operation.
 *
 * @category Transactions
 */
export declare enum TransactionGetMultiMode {
    /**
     * Indicates that the Transactional GetMulti op should prioritise latency.
     */
    PrioritiseLatency = "prioritise_latency",
    /**
     * Indicates that the Transactional GetMulti op should disable read skew detection.
     */
    DisableReadSkewDetection = "disable_read_skew_detection",
    /**
     * Indicates that the Transactional GetMulti op should prioritise read skew detection.
     */
    PrioritiseReadSkewDetection = "prioritise_read_skew_detection"
}
/**
 * Represents the mode of the Transactional GetMultiReplicasFromPreferredServerGroup operation.
 *
 * @category Transactions
 */
export declare enum TransactionGetMultiReplicasFromPreferredServerGroupMode {
    /**
     * Indicates that the Transactional GetMultiReplicasFromPreferredServerGroup op should prioritise latency.
     */
    PrioritiseLatency = "prioritise_latency",
    /**
     * Indicates that the Transactional GetMultiReplicasFromPreferredServerGroup op should disable read skew detection.
     */
    DisableReadSkewDetection = "disable_read_skew_detection",
    /**
     * Indicates that the Transactional GetMultiReplicasFromPreferredServerGroup op should prioritise read skew detection.
     */
    PrioritiseReadSkewDetection = "prioritise_read_skew_detection"
}
/**
 * Specifies the configuration options for Transactions cleanup.
 *
 * @category Transactions
 */
export type TransactionsCleanupConfig = {
    /**
     * Specifies the period of the cleanup system.
     */
    cleanupWindow?: number;
    /**
     * Specifies whether or not the cleanup system should clean lost attempts.
     */
    disableLostAttemptCleanup?: boolean;
    /**
     * Specifies whether or not the cleanup system should clean client attempts.
     */
    disableClientAttemptCleanup?: boolean;
};
/**
 * Specifies the configuration options for Transactions queries.
 *
 * @category Transactions
 */
export type TransactionsQueryConfig = {
    /**
     * Specifies the default scan consistency level for queries.
     */
    scanConsistency?: QueryScanConsistency;
};
/**
 * Specifies the configuration options for Transactions.
 *
 * @category Transactions
 */
export type TransactionsConfig = {
    /**
     * Specifies the level of synchronous durability level.
     */
    durabilityLevel?: DurabilityLevel;
    /**
     * 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.
     */
    kvTimeout?: number;
    /**
     * Specifies the default timeout for transactions.
     */
    timeout?: number;
    /**
     * Specifies the configuration for queries.
     */
    queryConfig?: TransactionsQueryConfig;
    /**
     * Specifies the configuration for the cleanup system.
     */
    cleanupConfig?: TransactionsCleanupConfig;
    /**
     * Specifies the Keyspace (bucket, scope & collection) for the transaction metadata.
     */
    metadataCollection?: TransactionKeyspace;
};
/**
 * Specifies the configuration options for a Transaction.
 *
 * @category Transactions
 */
export type TransactionOptions = {
    /**
     * Specifies the level of synchronous durability level.
     */
    durabilityLevel?: DurabilityLevel;
    /**
     * Specifies the timeout for the transaction.
     */
    timeout?: number;
};
/**
 * Represents the path to a document.
 *
 * @category Transactions
 */
export declare class TransactionGetMultiSpec<T extends CouchbaseClusterTypes, B extends BucketName<T>, S extends ScopeName<T, B>, C extends CollectionName<T, B, S>, const Key extends KeyspaceDocDef<T, B, S, C>['Key'] = KeyspaceDocDef<T, B, S, C>['Key']> {
    constructor(collection: Collection<T, B, S, C>, id: Key, transcoder?: Transcoder);
    /**
     * The Collection where the document belongs.
     */
    collection: Collection<T, B, S, C>;
    /**
     * The id (or key) of the document.
     */
    id: Key;
    /**
     * The Transcoder to encode/decode the document.
     */
    transcoder?: Transcoder;
    /**
     * @internal
     */
    _toCppDocumentId(): CppDocumentId;
}
/**
 * Represents the path to a document.
 *
 * @category Transactions
 */
export declare class TransactionGetMultiReplicasFromPreferredServerGroupSpec<T extends CouchbaseClusterTypes, B extends BucketName<T>, S extends ScopeName<T, B>, C extends CollectionName<T, B, S>, const Key extends KeyspaceDocDef<T, B, S, C>['Key'] = KeyspaceDocDef<T, B, S, C>['Key']> {
    constructor(collection: Collection<T, B, S, C>, id: Key, transcoder?: Transcoder);
    /**
     * The Collection where the document belongs.
     */
    collection: Collection<T, B, S, C>;
    /**
     * The id (or key) of the document.
     */
    id: Key;
    /**
     * The Transcoder to encode/decode the document.
     */
    transcoder?: Transcoder;
    /**
     * @internal
     */
    _toCppDocumentId(): CppDocumentId;
}
/**
 * Contains the results of a Transaction.
 *
 * @category Transactions
 */
export declare class TransactionResult {
    /**
     * @internal
     */
    constructor(data: {
        transactionId: string;
        unstagingComplete: boolean;
    });
    /**
     * The ID of the completed transaction.
     */
    transactionId: string;
    /**
     * Whether all documents were successfully unstaged and are now available
     * for non-transactional operations to see.
     */
    unstagingComplete: boolean;
}
export type TransactionDocInfo<T extends CouchbaseClusterTypes = DefaultClusterTypes, B extends BucketName<T> = BucketName<T>, S extends ScopeName<T, B> = ScopeName<T, B>, C extends CollectionName<T, B, S> = CollectionName<T, B, S>, Key extends KeyspaceDocDef<T, B, S, C>['Key'] = KeyspaceDocDef<T, B, S, C>['Key']> = {
    /**
     * The id of the document.
     */
    id: DocumentId<T, B, S, C, Key>;
    /**
     * The CAS of the document.
     */
    cas: Cas;
    /**
     * @internal
     */
    _links: CppTransactionLinks;
    /**
     * @internal
     */
    _metadata: CppTransactionGetMetaData;
};
/**
 * Contains the results of a transactional Get operation.
 *
 * @category Transactions
 */
export declare class TransactionGetResult<T extends CouchbaseClusterTypes = DefaultClusterTypes, B extends BucketName<T> = BucketName<T>, S extends ScopeName<T, B> = ScopeName<T, B>, C extends CollectionName<T, B, S> = CollectionName<T, B, S>, Key extends KeyspaceDocDef<T, B, S, C>['Key'] = KeyspaceDocDef<T, B, S, C>['Key']> {
    /**
     * The id of the document.
     */
    id: DocumentId<T, B, S, C, Key>;
    /**
     * The content of the document.
     */
    content: DocDefMatchingKey<Key, T, B, S, C>['Body'];
    /**
     * The CAS of the document.
     */
    cas: Cas;
    /**
     * @internal
     */
    _links: CppTransactionLinks;
    /**
     * @internal
     */
    _metadata: CppTransactionGetMetaData;
    /**
     * @internal
     */
    constructor(data: TransactionGetResult<T, B, S, C, Key>);
}
/**
 * Contains the results of a specific sub-operation within a transactional GetMulti operation.
 *
 * @category Transactions
 */
export declare class TransactionGetMultiResultEntry<Value = any, Err extends Error | undefined = Error | undefined> {
    /**
     * The error, if any, which occured when attempting to perform this sub-operation.
     */
    error: Err;
    /**
     * The value returned by the sub-operation.
     */
    value: Value;
    /**
     * @internal
     */
    constructor(data: {
        value: Value;
        error: Err;
    });
}
/**
 * Contains the results of a transactional GetMulti operation.
 *
 * @category Transactions
 */
export declare class TransactionGetMultiResult<Entries extends ReadonlyArray<TransactionGetMultiResultEntry>> {
    /**
     * The content of the document.
     */
    content: Entries;
    /**
     * @internal
     */
    constructor(data: {
        content: Entries;
    });
    /**
     * Indicates whether the document at the specified index exists.
     *
     * @param index The result index to check.
     */
    exists(index: number): boolean;
    /**
     * Provides the content at the specified index, if it exists.
     *
     * @param index The result index to check.
     */
    contentAt<Index extends number>(index: Index): ArrayMap<Entries, 'value'>[Index];
}
/**
 * Contains the results of a specific sub-operation within
 * a transactional GetMultiReplicasFromPreferredServerGroup operation.
 *
 * @category Transactions
 */
export declare class TransactionGetMultiReplicasFromPreferredServerGroupResultEntry<Value = any, Err extends Error | undefined = Error | undefined> {
    /**
     * The error, if any, which occured when attempting to access the document.
     */
    error: Err;
    /**
     * The value of the document.
     */
    value: Value;
    /**
     * @internal
     */
    constructor(data: {
        value: Value;
        error: Err;
    });
}
/**
 * Contains the results of a transactional GetMultiReplicasFromPreferredServerGroup operation.
 *
 * @category Transactions
 */
export declare class TransactionGetMultiReplicasFromPreferredServerGroupResult<Entries extends ReadonlyArray<TransactionGetMultiReplicasFromPreferredServerGroupResultEntry>> {
    /**
     * The content of the document.
     */
    content: Entries;
    /**
     * @internal
     */
    constructor(data: {
        content: Entries;
    });
    /**
     * Indicates whether the document at the specified index exists.
     *
     * @param index The result index to check.
     */
    exists(index: number): boolean;
    /**
     * Provides the content at the specified index, if it exists.
     *
     * @param index The result index to check.
     */
    contentAt<Index extends number>(index: Index): ArrayMap<Entries, 'value'>[Index];
}
/**
 * Contains the results of a transactional Exists operation.
 *
 * @category Transactions
 */
export declare class TransactionExistsResult<const Exists extends boolean, T extends CouchbaseClusterTypes = DefaultClusterTypes, B extends BucketName<T> = BucketName<T>, S extends ScopeName<T, B> = ScopeName<T, B>, C extends CollectionName<T, B, S> = CollectionName<T, B, S>, Key extends KeyspaceDocDef<T, B, S, C>['Key'] = KeyspaceDocDef<T, B, S, C>['Key']> {
    /**
     * The id of the document.
     */
    id: DocumentId<T, B, S, C, Key>;
    /**
     * Indicates whether the document existed or not.
     */
    exists: Exists;
    /**
     * The CAS of the document.
     */
    cas: If<Exists, Cas, undefined>;
    /**
     * @internal
     */
    _links: If<Exists, CppTransactionLinks, undefined>;
    /**
     * @internal
     */
    _metadata: If<Exists, CppTransactionGetMetaData, undefined>;
    /**
     * @internal
     */
    constructor(data: {
        id: DocumentId<T, B, S, C, Key>;
        exists: Exists;
        cas: If<Exists, Cas, undefined>;
        _links: If<Exists, CppTransactionLinks, undefined>;
        _metadata: If<Exists, CppTransactionGetMetaData, undefined>;
    });
}
/**
 * Contains the results of a transactional Query operation.
 *
 * @category Transactions
 */
export declare class TransactionQueryResult<TRow = any, WithMetrics extends boolean = false> {
    /**
     * The rows which have been returned by the query.
     */
    rows: TRow[];
    /**
     * The meta-data which has been returned by the query.
     */
    meta: QueryMetaData<WithMetrics>;
    /**
     * @internal
     */
    constructor(data: QueryResult<TRow, WithMetrics>);
}
/**
 * @category Transactions
 */
export type TransactionQueryOptions<T extends CouchbaseClusterTypes, WithMetrics extends boolean = false> = {
    queryContext?: QueryContext<T>;
    /**
     * Values to be used for the placeholders within the query.
     */
    parameters?: {
        [key: string]: any;
    } | any[];
    /**
     * Specifies the consistency requirements when executing the query.
     *
     * @default QueryScanConsistency.NotBounded
     * @see QueryScanConsistency
     */
    scanConsistency?: QueryScanConsistency;
    /**
     * Specifies whether this is an ad-hoc query, or if it should be prepared
     * for faster execution in the future.
     *
     * @default true
     */
    adhoc?: boolean;
    /**
     * The returned client context id for this query.
     */
    clientContextId?: string;
    /**
     * This is an advanced option, see the query service reference for more
     * information on the proper use and tuning of this option.
     */
    maxParallelism?: number;
    /**
     * This is an advanced option, see the query service reference for more
     * information on the proper use and tuning of this option.
     */
    pipelineBatch?: number;
    /**
     * This is an advanced option, see the query service reference for more
     * information on the proper use and tuning of this option.
     */
    pipelineCap?: 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.
     */
    scanWait?: number;
    /**
     * This is an advanced option, see the query service reference for more
     * information on the proper use and tuning of this option.
     */
    scanCap?: number;
    /**
     * Specifies that this query should be executed in read-only mode, disabling
     * the ability for the query to make any changes to the data.
     *
     * @default false
     */
    readOnly?: boolean;
    /**
     * Specifies the level of profiling that should be used for the query.
     */
    profile?: QueryProfileMode;
    /**
     * Specifies whether metrics should be captured as part of the execution of
     * the query.
     *
     * @default false
     */
    metrics?: WithMetrics;
    /**
     * Specifies any additional parameters which should be passed to the query engine
     * when executing the query.
     */
    raw?: {
        [key: string]: any;
    };
    /**
     * Specifies the default function to parse results from the query service.
     *
     * @default {@link JSON.parse}
     */
    queryResultParser?: (value: string) => any;
};
/**
 * @category Transactions
 */
export interface TransactionGetOptions {
    /**
     * Specifies an explicit transcoder to use for this specific operation.
     */
    transcoder?: Transcoder;
}
/**
 * @category Transactions
 */
export interface TransactionGetReplicaFromPreferredServerGroupOptions {
    /**
     * Specifies an explicit transcoder to use for this specific operation.
     */
    transcoder?: Transcoder;
}
/**
 * @category Transactions
 */
export interface TransactionGetMultiOptions {
    /**
     * Specifies a mode to use for this specific operation.
     */
    mode?: TransactionGetMultiMode;
}
/**
 * @category Transactions
 */
export interface TransactionGetMultiReplicasFromPreferredServerGroupOptions {
    /**
     * Specifies a mode to use for this specific operation.
     */
    mode?: TransactionGetMultiReplicasFromPreferredServerGroupMode;
}
/**
 * @category Transactions
 */
export interface TransactionInsertOptions {
    /**
     * Specifies an explicit transcoder to use for this specific operation.
     */
    transcoder?: Transcoder;
}
/**
 * @category Transactions
 */
export interface TransactionReplaceOptions {
    /**
     * Specifies an explicit transcoder to use for this specific operation.
     */
    transcoder?: Transcoder;
}
/**
 * Represents a {@link TransactionAttemptContext} where the bucket has been defined.
 */
export type TransactionAttemptContextBucket<T extends CouchbaseClusterTypes, B extends BucketName<T> = never> = ReturnType<TransactionAttemptContext<T, never, B>['bucket']>;
type SpecsToEntries<Specs> = Specs extends readonly [TransactionGetMultiSpec<infer T, infer B, infer S, infer C, infer Key>, ...infer Rest] ? [
    TransactionGetMultiResultEntry<DocDefMatchingKey<Key, T, B, S, C>['Body']>,
    ...SpecsToEntries<Rest>
] : [
];
type SpecsToPreferredEntries<Specs> = Specs extends readonly [TransactionGetMultiReplicasFromPreferredServerGroupSpec<infer T, infer B, infer S, infer C, infer Key>, ...infer Rest] ? [
    TransactionGetMultiReplicasFromPreferredServerGroupResultEntry<DocDefMatchingKey<Key, T, B, S, C>['Body']>,
    ...SpecsToPreferredEntries<Rest>
] : [
];
/**
 * Represents a {@link TransactionAttemptContext} where the bucket and the scope have been defined.
 */
export type TransactionAttemptContextScope<T extends CouchbaseClusterTypes, B extends BucketName<T> = never, S extends ScopeName<T, B> = never> = ReturnType<ReturnType<TransactionAttemptContext<T, never, B, S>['bucket']>['scope']>;
/**
 * Provides an interface to preform transactional operations in a transaction.
 *
 * @category Transactions
 */
export declare class TransactionAttemptContext<T extends CouchbaseClusterTypes, Instance extends Collection<T, B, S, C> = never, B extends BucketName<T> = never, S extends ScopeName<T, B> = never, C extends CollectionName<T, B, S> = never> {
    private cluster;
    private _impl;
    private transcoder;
    /**
     * @internal
     */
    constructor(txns: Transactions<T>, config?: TransactionOptions);
    /**
    @internal
    */
    get impl(): CppTransaction;
    /**
     * @internal
     */
    _newAttempt(): Promise<void>;
    /**
     * Retrieves the value of a document from the collection.
     *
     * @param collection The collection the document lives in.
     * @param key The document key to retrieve.
     * @param options Optional parameters for this operation.
     */
    get<LInstance extends AnyCollection, CKS extends CollectionKeyspace<LInstance>, const LKey extends KeyspaceDocDef<T, CKS['bucket'], CKS['scope'], CKS['collection']>['Key'], const Key extends KeyspaceDocDef<T, B, S, C>['Key']>(...args: If<IsNever<Instance>, [
        collection: LInstance,
        key: LKey,
        options?: TransactionGetOptions
    ], [
        key: Key,
        options?: TransactionGetOptions
    ]>): Promise<If<IsNever<Instance>, TransactionGetResult<CKS['clusterTypes'], CKS['bucket'], CKS['scope'], CKS['collection'], LKey>, TransactionGetResult<T, B, S, C, Key>>>;
    /**
     * Retrieves the value of a document from the collection.
     *
     * @param collection The collection the document lives in.
     * @param key The document key to retrieve.
     * @param options Optional parameters for this operation.
     */
    getReplicaFromPreferredServerGroup<LInstance extends AnyCollection, CKS extends CollectionKeyspace<LInstance>, const LKey extends KeyspaceDocDef<T, CKS['bucket'], CKS['scope'], CKS['collection']>['Key'], const Key extends KeyspaceDocDef<T, B, S, C>['Key']>(...args: If<IsNever<Instance>, [
        collection: LInstance,
        key: LKey,
        options?: TransactionGetReplicaFromPreferredServerGroupOptions
    ], [
        key: Key,
        options?: TransactionGetOptions
    ]>): Promise<TransactionGetResult>;
    /**
     * Retrieves the documents specified in the list of specs.
     *
     * @param specs The documents to retrieve.
     * @param options Optional parameters for this operation.
     */
    getMulti<const Specs extends ReadonlyArray<TransactionGetMultiSpec<any, any, any, any>>>(specs: Specs, options?: TransactionGetMultiOptions): Promise<TransactionGetMultiResult<SpecsToEntries<Specs>>>;
    /**
     *
     * @param specs The documents to retrieve.
     * @param options Optional parameters for this operation.
     */
    getMultiReplicasFromPreferredServerGroup<const Specs extends ReadonlyArray<TransactionGetMultiReplicasFromPreferredServerGroupSpec<any, any, any, any>>>(specs: Specs, options?: TransactionGetMultiReplicasFromPreferredServerGroupOptions): Promise<TransactionGetMultiReplicasFromPreferredServerGroupResult<SpecsToPreferredEntries<Specs>>>;
    /**
     * Check if a specific document exists in the collection or not.
     *
     * @param collection The collection the document may lives in.
     * @param key The document key to check.
     */
    exists<LInstance extends AnyCollection, CKS extends CollectionKeyspace<LInstance>, const LKey extends KeyspaceDocDef<T, CKS['bucket'], CKS['scope'], CKS['collection']>['Key'], const Key extends KeyspaceDocDef<T, B, S, C>['Key']>(...args: If<IsNever<Instance>, [collection: LInstance, key: LKey], [key: Key]>): Promise<If<IsNever<Instance>, TransactionExistsResult<true, CKS['clusterTypes'], CKS['bucket'], CKS['scope'], CKS['collection'], LKey> | TransactionExistsResult<false, CKS['clusterTypes'], CKS['bucket'], CKS['scope'], CKS['collection'], LKey>, TransactionExistsResult<true, T, B, S, C, Key> | TransactionExistsResult<false, T, B, S, C, Key>>>;
    /**
     * Inserts a new document to the collection, failing if the document already exists.
     *
     * @param collection The {@link Collection} the document lives in.
     * @param key The document key to insert.
     * @param content The document content to insert.
     * @param options Optional parameters for this operation.
     */
    insert<LInstance extends AnyCollection, CKS extends CollectionKeyspace<LInstance>, const LKey extends KeyspaceDocDef<T, CKS['bucket'], CKS['scope'], CKS['collection']>['Key'], const Key extends KeyspaceDocDef<T, B, S, C>['Key']>(...args: If<IsNever<Instance>, [
        collection: LInstance,
        key: LKey,
        content: DocDefMatchingKey<LKey, CKS['clusterTypes'], CKS['bucket'], CKS['scope'], CKS['collection']>['Body'],
        options?: TransactionInsertOptions
    ], [
        key: Key,
        content: DocDefMatchingKey<Key, T, B, S, C>['Body'],
        options?: TransactionInsertOptions
    ]>): Promise<If<IsNever<Instance>, TransactionGetResult<CKS['clusterTypes'], CKS['bucket'], CKS['scope'], CKS['collection'], LKey>, TransactionGetResult<T, B, S, C, Key>>>;
    /**
     * Replaces a document in a collection.
     *
     * @param doc The document to replace.
     * @param content The document content to insert.
     * @param options Optional parameters for this operation.
     */
    replace<LB extends BucketName<T>, LS extends ScopeName<T, LB>, LC extends CollectionName<T, LB, LS>, const Key extends KeyspaceDocDef<T, LB, LS, LC>['Key']>(doc: Exclude<TransactionDocInfo<T, LB, LS, LC, Key>, 'cas'> & {
        cas: CasInput;
    }, content: DocDefMatchingKey<Key, T, LB, LS, LC>['Body'], options?: TransactionReplaceOptions): Promise<TransactionGetResult<T, LB, LS, LC, Key>>;
    /**
     * Removes a document from a collection.
     *
     * @param doc The document to remove.
     */
    remove<LB extends BucketName<T>, LS extends ScopeName<T, LB>, LC extends CollectionName<T, LB, LS>, const Key extends KeyspaceDocDef<T, LB, LS, LC>['Key']>(doc: Exclude<TransactionDocInfo<T, LB, LS, LC, Key>, 'cas'> & {
        cas: CasInput;
    }): Promise<void>;
    /**
     * Executes a query in the context of this transaction.
     *
     * @param statement The statement to execute.
     * @param options Optional parameters for this operation.
     */
    query<TRow = any, WithMetrics extends boolean = false>(statement: string, options?: TransactionQueryOptions<T, WithMetrics>): Promise<TransactionQueryResult<TRow, WithMetrics>>;
    /**
     * @internal
     */
    _commit(): Promise<TransactionResult>;
    /**
     * @internal
     */
    _rollback(): Promise<void>;
    bucket<LB extends BucketName<T>>(this: TransactionAttemptContext<T>, bucketName: LB): {
        scope: <LS extends ScopeName<T, LB>>(scopeName: LS) => {
            collection: <LC extends CollectionName<T, LB, LS>>(collectionName: LC) => TransactionAttemptContext<T, Collection<T, LB, LS, LC>, LB, LS, LC>;
        };
    };
}
/**
 * Provides an interface to access transactions.
 *
 * @category Transactions
 */
export declare class Transactions<T extends CouchbaseClusterTypes> {
    private _cluster;
    private _impl;
    /**
    @internal
    */
    constructor(cluster: Cluster<T>, config?: TransactionsConfig);
    get cluster(): Cluster<T>;
    /**
    @internal
    */
    get impl(): CppTransactions;
    /**
    @internal
    */
    _close(): Promise<void>;
    /**
     * Executes a transaction.
     *
     * @param logicFn The transaction lambda to execute.
     * @param config Configuration operations for the transaction.
     */
    run(logicFn: (attempt: TransactionAttemptContext<T>) => Promise<void>, config?: TransactionOptions): Promise<TransactionResult>;
}
export {};