import { DynamoDB } from "aws-sdk";
import { PartitionAndSortKey, PartitionKey, PartitionKeyAndSortKeyPrefix } from "./keys";
import { QueryBuilder } from "./QueryBuilder";
import { ParallelScanConfig, ScanBuilder } from "./ScanBuilder";
import { Table } from "./Table";
import { ExtractKeyType, GroupedModels, TaggedModel } from "./types";
export interface Options {
    xRayTracingEnabled?: boolean;
    consistentReads?: boolean;
}
export interface GetOptions {
    consistentRead?: boolean;
}
export interface QueryOptions {
    consistentRead?: boolean;
}
export interface ScanOptions {
    consistentRead?: boolean;
    parallel?: ParallelScanConfig;
}
/** A thin wrapper around the DynamoDB sdk client that
 * does auto mapping between JSON <=> DynamoDB Items
 */
export declare class Beyonce {
    private table;
    private client;
    private consistentReads;
    constructor(table: Table<string, string>, dynamo: DynamoDB, options?: Options);
    /** Retrieve a single Item out of Dynamo */
    get<T extends TaggedModel>(key: PartitionAndSortKey<T>, options?: GetOptions): Promise<T | undefined>;
    /** Write an item into Dynamo */
    put<T extends TaggedModel>(item: T): Promise<void>;
    /** Performs a (partial) update on an existing item in Dynamo.*/
    update<T extends TaggedModel>(key: PartitionAndSortKey<T>, updateFunc: (lens: T) => void): Promise<T>;
    delete<T extends TaggedModel>(key: PartitionAndSortKey<T>): Promise<void>;
    /** BatchGet items */
    batchGet<T extends PartitionAndSortKey<TaggedModel>>(params: {
        keys: T[];
        consistentRead?: boolean;
    }): Promise<{
        items: GroupedModels<ExtractKeyType<T>>;
        unprocessedKeys: T[];
    }>;
    batchWrite<T extends TaggedModel>(params: {
        putItems?: T[];
        deleteItems?: PartitionAndSortKey<T>[];
    }): Promise<{
        unprocessedPuts: T[];
        unprocessedDeletes: PartitionAndSortKey<T>[];
    }>;
    /**
     * Perform N Dynamo operations in an atomic transaction.
     *
     * @param params.putItems Set `failIfNotUnique` to true on a record within putItems to cancel the transaction if a
     *  record with the same partition key and sort key (if applicable) already exists.
     */
    batchWriteWithTransaction<T extends TaggedModel>(params: {
        clientRequestToken?: string;
        putItems?: (T & {
            failIfNotUnique?: boolean;
        })[];
        deleteItems?: PartitionAndSortKey<T>[];
    }): Promise<void>;
    query<T extends TaggedModel>(key: PartitionKey<T> | PartitionKeyAndSortKeyPrefix<T>, options?: QueryOptions): QueryBuilder<T>;
    queryGSI<T extends TaggedModel>(gsiName: string, gsiKey: PartitionKey<T>, options?: QueryOptions): QueryBuilder<T>;
    scan<T extends TaggedModel = TaggedModel>(options?: ScanOptions): ScanBuilder<T>;
    private doSingleBatchGet;
}
//# sourceMappingURL=Beyonce.d.ts.map