import { type Rangable, Range } from './range';
import * as RPC from './rpc';
import type { CallOptions } from '../base/options';
import { type NSApplicator, PromiseWrap } from '../base/util';
export declare const comparator: {
    '==': RPC.CompareResult;
    '===': RPC.CompareResult;
    '>': RPC.CompareResult;
    '<': RPC.CompareResult;
    '!=': RPC.CompareResult;
    '!==': RPC.CompareResult;
};
export interface ICompareTarget {
    value: RPC.CompareTarget;
    key: keyof RPC.ICompare;
}
export interface IOperation {
    op: () => Promise<RPC.IRequestOp>;
}
export declare const compareTarget: {
    [key in keyof typeof RPC.CompareTarget]: keyof RPC.ICompare;
};
export declare abstract class RangeBuilder<T> extends PromiseWrap<T> implements IOperation {
    protected readonly namespace: NSApplicator;
    protected request: RPC.IRangeRequest;
    protected callOptions: CallOptions | undefined;
    constructor(namespace: NSApplicator);
    revision(rev: number | string): this;
    serializable(serializable: boolean): this;
    minModRevision(minModRevision: number | string): this;
    maxModRevision(maxModRevision: number | string): this;
    minCreateRevision(minCreateRevision: number | string): this;
    maxCreateRevision(maxCreateRevision: number | string): this;
    options(options: CallOptions | undefined): this;
    op(): Promise<RPC.IRequestOp>;
}
export declare class SingleRangeBuilder extends RangeBuilder<string | null> {
    private readonly kv;
    constructor(kv: RPC.KVClient, namespace: NSApplicator, key: string | Buffer);
    json(): Promise<unknown>;
    string(encoding?: BufferEncoding): Promise<string | null>;
    number(): Promise<number | null>;
    buffer(): Promise<Buffer | null>;
    exists(): Promise<boolean>;
    exec(): Promise<RPC.IRangeResponse>;
    protected createPromise(): Promise<string | null>;
}
export declare class MultiRangeBuilder extends RangeBuilder<Record<string, string>> {
    private readonly kv;
    constructor(kv: RPC.KVClient, namespace: NSApplicator);
    prefix(value: string | Buffer): this;
    inRange(r: Rangable): this;
    all(): this;
    limit(count: number): this;
    sort(target: keyof typeof RPC.SortTarget, order: keyof typeof RPC.SortOrder): this;
    count(): Promise<number>;
    keys(encoding?: BufferEncoding): Promise<string[]>;
    keyBuffers(): Promise<Buffer[]>;
    json(): Promise<Record<string, unknown>>;
    strings(encoding?: BufferEncoding): Promise<Record<string, string>>;
    numbers(): Promise<Record<string, number>>;
    buffers(): Promise<Record<string, Buffer>>;
    exec(): Promise<RPC.IRangeResponse>;
    protected createPromise(): Promise<Record<string, string>>;
    private mapValues;
}
export declare class DeleteBuilder extends PromiseWrap<RPC.IDeleteRangeResponse> {
    private readonly kv;
    private readonly namespace;
    private readonly request;
    private callOptions;
    constructor(kv: RPC.KVClient, namespace: NSApplicator);
    key(value: string | Buffer): this;
    prefix(value: string | Buffer): this;
    range(range: Range): this;
    all(): this;
    inRange(r: Rangable): this;
    getPrevious(): Promise<RPC.IKeyValue[]>;
    options(options: CallOptions | undefined): this;
    exec(): Promise<RPC.IDeleteRangeResponse>;
    op(): Promise<RPC.IRequestOp>;
    protected createPromise(): Promise<RPC.IDeleteRangeResponse>;
}
export declare class PutBuilder extends PromiseWrap<RPC.IPutResponse> {
    private readonly kv;
    private readonly namespace;
    private readonly request;
    private leaseFilter?;
    private callOptions;
    constructor(kv: RPC.KVClient, namespace: NSApplicator, key: string | Buffer);
    value(value: string | Buffer | number): this;
    lease(lease: number | string | Promise<string | number>): this;
    ignoreLease(): this;
    options(options: CallOptions | undefined): this;
    getPrevious(): Promise<RPC.IKeyValue & {
        header: RPC.IResponseHeader;
    }>;
    touch(): Promise<RPC.IPutResponse>;
    exec(): Promise<RPC.IPutResponse>;
    op(): Promise<RPC.IRequestOp>;
    protected createPromise(): Promise<RPC.IPutResponse>;
    private applyLease;
}
export declare class ComparatorBuilder {
    private readonly kv;
    private readonly namespace;
    private readonly request;
    private callOptions;
    constructor(kv: RPC.KVClient, namespace: NSApplicator);
    options(options: CallOptions | undefined): this;
    and(key: string | Buffer, column: keyof typeof RPC.CompareTarget, cmp: keyof typeof comparator, value: string | Buffer | number): this;
    then(...clauses: Array<RPC.IRequestOp | IOperation>): this;
    else(...clauses: Array<RPC.IRequestOp | IOperation>): this;
    commit(): Promise<RPC.ITxnResponse>;
    mapOperations(ops: Array<RPC.IRequestOp | IOperation>): Array<Promise<RPC.IRequestOp>>;
}