import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { CompoundKey, SortKey } from '@paradoxical-io/types';
import { Metrics, Monitoring } from '../../monitoring';
import { DynamoDao } from '../mapper';
import { DynamoTableName } from '../util';
export declare class PartitionedKeyValueTableDao<T extends string> implements DynamoDao {
    partitionKey: T;
    sortKey: SortKey;
    data: string;
    md5?: string;
}
export interface PartitionKeyMappings {
    sortKeyFieldName: string;
    sortKeyFieldAWSType: 'S' | 'N';
    partitionKeyFieldName: string;
    dataFieldName: string;
    md5: 'md5';
}
/**
 * A key value table where the _sort_ key is namespaced.
 *
 * The reason for this is to allow to query all the values based on the partition key. Imagine
 * wanting to answer "give me all the keys for userId X" and get the fact that it has some bank keys
 * and some user keys, etc.
 */
export declare class PartitionedKeyValueTable {
    readonly dynamo: DynamoDBClient;
    readonly tableName: string;
    private readonly logger;
    readonly metrics: Metrics;
    constructor({ dynamo, tableName, monitoring, }: {
        dynamo?: DynamoDBClient;
        tableName: DynamoTableName;
        monitoring?: Monitoring;
    });
    /**
     * Method to append data to a key that points to a value list.
     *
     * @param key compound key that indexes to a `value[]`
     * @param data to be appended to the key
     * @param setInclusion if this returns `true`, then nothing is added to the list
     * @returns void
     */
    addToSet<K extends string, V>(key: CompoundKey<K, V[]>, data: V | V[], setInclusion?: (left: V, right: V) => boolean): Promise<boolean>;
    /**
     * Clears an entire partition, including all sort keys
     * @param partition
     */
    clear<P extends string>(partition: P): Promise<void>;
    /**
     * Deletes only a specific sort key
     * @param key
     */
    delete<P extends string>(key: CompoundKey<P>): Promise<void>;
    /**
     * If the key exists in the DynamoDB table, returns true. Otherwise, returns false.
     * @param key
     */
    exists<K extends string, V>(key: CompoundKey<K, V>): Promise<boolean>;
    /**
     * Method to check if data exists on a list of values on a key.
     *
     * @param key compound key that indexes to a `value[]`
     * @param data to check if it exists in the value list
     * @param setInclusion function to check if element exists in a list
     * @returns
     */
    existsInSet<K extends string, V>(key: CompoundKey<K, V[]>, data: V, setInclusion?: (left: V, right: V) => boolean): Promise<boolean>;
    get<T, P extends string>(key: CompoundKey<P, T>): Promise<T | undefined>;
    /**
     * Lists all values in a partition
     * @param partition
     */
    listAll(partition: string): AsyncGenerator<Array<{
        key: string;
        value: string;
    }>>;
    /**
     * Removes an element from a set of data.
     *
     * @param key compound key that indexes to a `value[]`
     * @param data to be removed from the set
     * @param setInclusion how to determine if the item is in the set
     * @returns
     */
    removeFromSet<K extends string, V>(key: CompoundKey<K, V[]>, data: V | V[], setInclusion?: (left: V, right: V) => boolean): Promise<boolean>;
    /**
     * Removes an element from a set of data.
     *
     * @param key compound key that indexes to a `value[]`
     * @param toRemove how to determine which item to remove
     * @returns
     */
    removeFromSetByKey<K extends string, V>(key: CompoundKey<K, V[]>, toRemove: (v: V) => boolean): Promise<boolean>;
    set<T, P extends string>(key: CompoundKey<P, T>, data: T): Promise<void>;
    setBatch<T, P extends string>(keys: Array<{
        key: CompoundKey<P, T>;
        data: T;
    }>): Promise<void>;
    /**
     * Sets the value if it doesn't exist. Returns true if was inserted or false if not (due to duplicate found)
     *
     * Does this atomically.
     * @param key
     * @param data
     */
    setIfNotExists<T, P extends string>(key: CompoundKey<P, T>, data: T): Promise<boolean>;
    /**
     * Method to update data to a key that points to a value list.
     * If the data does not exist in the list already, it's still added to the list.
     *
     * @param key compound key that indexes to a `value[]`
     * @param data to be appended to the key
     * @param setInclusion keys for which this returns `true` are removed from the list before appending the new value
     * @returns true if the new value was appended to the list, false if the key was not found
     */
    updateInSet<K extends string, V>(key: CompoundKey<K, V[]>, data: V, setInclusion?: (value: V) => boolean): Promise<boolean>;
    protected sortKey<P extends string>(key: CompoundKey<P>): SortKey;
    protected partitionKey<P extends string>(key: CompoundKey<P>): P;
    protected mappings(): PartitionKeyMappings;
    protected getRaw<T, P extends string>(key: CompoundKey<P, T>): Promise<{
        data: T;
        md5?: string;
    } | undefined>;
    protected setIfMd5Matches<T, P extends string>(key: CompoundKey<P, T>, data: T, previousMd5: string | undefined): Promise<boolean>;
    private existsRaw;
    private setRawBatch;
    private setRawAtomic;
    private deleteSortKey;
    private deletePartition;
}
//# sourceMappingURL=partitionedKeyTable.d.ts.map