dynamodb-ts-model/dist/DynamoBatch.d.ts

A DynamoDB model/client with full TypeScript typings

import { DeleteParams, GetParams, Item, KeyAttributes, KeyValue, ProjectionKeys, PutParams } from './types';
import { DynamoWrapper } from './DynamoWrapper';
import { DynamoModel } from './DynamoModel';
type BatchItem<T extends Item = Item> = {
    model: DynamoModel<T>;
    item: T;
};
type BatchCommand<T extends Item = Item> = {
    model: DynamoModel<T>;
    command: 'put' | 'delete';
    key: KeyValue<T, KeyAttributes<T>>;
};
type BatchResult<T> = {
    items: T[];
    done: boolean;
};
export declare class DynamoBatchStatementProxy extends DynamoWrapper {
    get<T extends Item, K extends KeyAttributes<T>, P extends ProjectionKeys<T>>(model: DynamoModel<T, K>, ...paramsList: Array<GetParams<T, K, P>>): DynamoBatchGetStatement<T>;
    put<T extends Item, K extends KeyAttributes<T>, B extends Item>(model: DynamoModel<T, K, any, B>, ...paramsList: Array<Pick<PutParams<T, B>, 'item'>>): DynamoBatchWriteStatement<T>;
    delete<T extends Item, K extends KeyAttributes<T>>(model: DynamoModel<T, K>, ...paramsList: Array<Pick<DeleteParams<T, K>, 'key'>>): DynamoBatchWriteStatement<T>;
}
export declare class DynamoBatchGetStatement<T0 extends Item> extends DynamoWrapper {
    private requestMap;
    private readonly modelMap;
    get<T extends Item, K extends KeyAttributes<T>, P extends ProjectionKeys<T>>(model: DynamoModel<T, K>, ...paramsList: Array<GetParams<T, K, P>>): DynamoBatchGetStatement<T0 | T>;
    /**
     * Execute the statements in this batch and return the retrieved items.
     * Note that while done is false, some statements were not executed and this method should then be called again,
     * preferably after utilizing exponential backoff.
     */
    execute<T extends Item = T0>(): Promise<BatchResult<BatchItem<T>>>;
    /**
     * Returns an iterator which executes the statements in this batch and returns the retrieved items until done,
     * adding a random delay between batches.
     */
    executeIterator<T extends Item = T0>(): AsyncGenerator<BatchItem<T>>;
}
export declare class DynamoBatchWriteStatement<T0 extends Item> extends DynamoWrapper {
    private requestMap;
    private readonly modelMap;
    put<T extends Item, K extends KeyAttributes<T>, B extends Item>(model: DynamoModel<T, K, any, B>, ...paramsList: Array<Pick<PutParams<T, B>, 'item'>>): DynamoBatchWriteStatement<T0 | T>;
    delete<T extends Item, K extends KeyAttributes<T>>(model: DynamoModel<T, K>, ...paramsList: Array<Pick<DeleteParams<T, K>, 'key'>>): DynamoBatchWriteStatement<T0 | T>;
    /**
     * Execute the statements in this batch. Note that while done is false, some statements were not executed and this
     * method should then be called again, preferably after utilizing exponential backoff.
     */
    execute<T extends Item = T0>(): Promise<BatchResult<BatchCommand<T>>>;
    /**
     * Returns an iterator which executes the statements in this batch until done, adding a random delay between batches.
     */
    executeIterator<T extends Item = T0>(): AsyncGenerator<BatchCommand<T>>;
}
export {};
//# sourceMappingURL=DynamoBatch.d.ts.map