import AWS = require('aws-sdk');
import { TypeShape, Value } from '@punchcard/shape';
import { Compact } from 'typelevel-ts';
import { DSL } from './dsl';
import { Mapper } from './mapper';
export interface BaseClientProps<T extends TypeShape, K extends DDB.KeyOf<T>> {
    /**
     * Record typr of the table's properties.
     */
    data: T;
    /**
     * Key of the Table.
     */
    key: K;
    /**
     * DynamoDB Table Name.
     */
    tableName: string;
    /**
     * Name of the DynamoDB Index.
     *
     * @default - no index
     */
    indexName?: string;
    /**
     * Configured AWS DynamoDB Client.
     *
     * @default - one using the default environment configuration is created for you.
     */
    client?: AWS.DynamoDB;
}
export declare class BaseClient<T extends TypeShape<any>, K extends DDB.KeyOf<T>> {
    readonly client: AWS.DynamoDB;
    readonly mapper: Mapper<T>;
    readonly tableName: string;
    readonly indexName?: string;
    readonly hashKeyMapper: Mapper<DDB.HashKeyShape<T, K>>;
    readonly sortKeyMapper: Mapper<DDB.SortKeyShape<T, K>>;
    readonly readKey: (key: AWS.DynamoDB.Key) => DDB.KeyValue<T, K>;
    readonly writeKey: (key: DDB.KeyValue<T, K>) => any;
    protected readonly dsl: DSL.Root<T>;
    readonly type: T;
    readonly key: K;
    constructor(config: BaseClientProps<T, K>);
    scan(): Promise<Value.Of<T>[]>;
    query(condition: DDB.QueryCondition<T, K>, props?: DDB.QueryProps<T, K>): Promise<DDB.QueryOutput<T, K>>;
}
export interface TableClientProps<T extends TypeShape, K extends DDB.KeyOf<T>> extends Omit<BaseClientProps<T, K>, 'indexName'> {
}
export declare class TableClient<T extends TypeShape, K extends DDB.KeyOf<T>> extends BaseClient<T, K> {
    constructor(config: TableClientProps<T, K>);
    get(key: DDB.KeyValue<T, K>): Promise<Value.Of<T> | undefined>;
    batchGet(keys: DDB.KeyValue<T, K>[]): Promise<Value.Of<T>[]>;
    put(item: Value.Of<T>, props?: {
        if?: DDB.Condition<T>;
    }): Promise<import("aws-sdk/lib/request").PromiseResult<AWS.DynamoDB.PutItemOutput, AWS.AWSError>>;
    /**
     * Put a batch of records
     *
     * @param batch
     * @returns failed PutRequests
     */
    batchPut(batch: Value.Of<T>[]): Promise<AWS.DynamoDB.WriteRequest[]>;
    update(key: DDB.KeyValue<T, K>, props: DDB.Update<T>): Promise<import("aws-sdk/lib/request").PromiseResult<AWS.DynamoDB.UpdateItemOutput, AWS.AWSError>>;
}
export interface IndexClientProps<T extends TypeShape<any>, K extends DDB.KeyOf<T>> extends TableClientProps<T, K> {
    /**
     * Name of the DynamoDB Index.
     * Required for the IndexClient.
     */
    indexName: string;
}
/**
 * Client to Query and Scan a DynamoDB Index.
 */
export declare class IndexClient<T extends TypeShape, K extends DDB.KeyOf<T>> extends BaseClient<T, K> {
    constructor(config: IndexClientProps<T, K>);
}
export declare namespace DDB {
    type _QueryOutput<T extends TypeShape<any>, K extends KeyOf<T>> = Compact<Omit<AWS.DynamoDB.QueryOutput, 'Items' | 'LastEvaulatedKey'> & {
        Items?: Value.Of<T>[];
        LastEvaluatedKey?: KeyValue<T, K>;
    }>;
    export interface QueryOutput<T extends TypeShape<any>, K extends KeyOf<T>> extends _QueryOutput<T, K> {
    }
    export type HashKey<T> = keyof T;
    export type SortKey<T> = [keyof T, keyof T];
    export interface KeyOf<T extends TypeShape> {
        partition: keyof T['Members'];
        sort?: keyof T['Members'] | undefined;
    }
    export type KeyNames<T extends TypeShape<any>, K extends KeyOf<T>> = K extends {
        partition: infer PK;
        sort?: undefined;
    } ? PK : K extends {
        partition: infer PK;
        sort: infer SK;
    } ? PK | SK : never;
    export type KeyValue<T extends TypeShape<any>, K extends KeyOf<T>> = {
        [k in KeyNames<T, K>]: Value.Of<T['Members'][k]>;
    };
    export type HashKeyName<K> = K extends {
        partition: infer H;
    } ? H : never;
    export type HashKeyValue<T extends TypeShape<any>, K extends KeyOf<T>> = Value.Of<HashKeyShape<T, K>>;
    export type HashKeyShape<T extends TypeShape<any>, K extends KeyOf<T>> = T['Members'][HashKeyName<K>];
    export type SortKeyName<K> = K extends {
        sort?: infer S;
    } ? S : undefined;
    export type SortKeyValue<T extends TypeShape<any>, K extends KeyOf<T>> = Value.Of<SortKeyShape<T, K>>;
    export type SortKeyShape<T extends TypeShape<any>, K extends KeyOf<T>> = T['Members'][SortKeyName<K>];
    export type QueryCondition<T extends TypeShape<any>, K extends KeyOf<T>> = SortKeyName<K> extends undefined ? {
        [k in HashKeyName<K>]: HashKeyValue<T, K>;
    } : {
        [k in HashKeyName<K>]: HashKeyValue<T, K>;
    } & {
        [k in SortKeyName<K>]?: (i: DSL.Of<SortKeyShape<T, K>>) => DSL.Bool;
    };
    export interface QueryProps<T extends TypeShape<any>, K extends KeyOf<T>> {
        filter?: DDB.Condition<T>;
        Limit?: number;
        ExclusiveStartKey?: DDB.KeyValue<T, K>;
        ContinuationToken?: string;
        ScanIndexForward?: boolean;
    }
    export type Condition<T extends TypeShape<any>> = (item: DSL.Root<T>) => DSL.Bool;
    export interface Update<T extends TypeShape<any>> {
        actions: (item: DSL.Root<T>) => DSL.Action[];
        if?: DDB.Condition<T>;
    }
    export {};
}
//# sourceMappingURL=client.d.ts.map