import { DynamoDB } from 'aws-sdk';
import { DocumentClient } from 'aws-sdk/clients/dynamodb';
/**
 * Objects with open properties
 */
export interface AnyObject {
    [property: string]: any;
}
export declare type QueryInput = DynamoDB.DocumentClient.QueryInput;
/**
 * DynamoDB supported operators
 */
export declare type DynamoDBOperators = '=' | '>' | '>=' | '<' | '<=' | '<>' | 'BETWEEN' | 'BEGINS_WITH' | 'IN' | 'EXISTS' | 'CONTAINS';
/**
 * Operators for where clauses
 */
export declare type FilterOperators = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'inq' | 'between' | 'like' | 'exists' | 'beginsWith';
/**
 * Matching predicate comparison
 */
export declare type PredicateComparison<PT> = {
    eq?: PT;
    neq?: PT;
    gt?: PT;
    gte?: PT;
    lt?: PT;
    lte?: PT;
    inq?: PT[];
    nin?: PT[];
    between?: [PT, PT];
    exists?: boolean;
    like?: PT;
    nlike?: PT;
    ilike?: PT;
    nilike?: PT;
    beginsWith?: PT;
};
/**
 * Value types for `{propertyName: value}`
 */
export declare type ShortHandEqualType = string | number | boolean | Date;
/**
 * Key types of a given model, excluding operators
 */
export declare type KeyOf<MT extends object> = Exclude<Extract<keyof MT, string>, FilterOperators>;
/**
 * Condition clause
 *
 * @example
 * ```ts
 * {
 *   name: {inq: ['John', 'Mary']},
 *   status: 'ACTIVE',
 *   age: {gte: 40}
 * }
 * ```
 */
export declare type Condition<MT extends object> = {
    [P in KeyOf<MT>]?: PredicateComparison<MT[P]> | (MT[P] & ShortHandEqualType);
};
/**
 * Where clause
 *
 * @example
 * ```ts
 * {
 *   name: {inq: ['John', 'Mary']},
 *   status: 'ACTIVE'
 *   and: [...],
 *   or: [...],
 * }
 * ```
 */
export declare type Where<MT extends object = AnyObject> = Condition<MT> | AndClause<MT> | OrClause<MT>;
/**
 * And clause
 *
 * @example
 * ```ts
 * {
 *   and: [...],
 * }
 * ```
 */
export interface AndClause<MT extends object> {
    and: Where<MT>[];
}
/**
 * Or clause
 *
 * @example
 * ```ts
 * {
 *   or: [...],
 * }
 * ```
 */
export interface OrClause<MT extends object> {
    or: Where<MT>[];
}
/**
 * Order by direction
 */
export declare enum Direction {
    ASC = "ASC",
    DESC = "DESC"
}
/**
 * Selection of fields
 *
 * Example:
 * fields: ['id', 'isActive]
 */
export declare type Fields<MT = AnyObject> = Array<keyof MT>;
/**
 * Query filter object
 */
export interface Filter<MT extends object = AnyObject> {
    /**
     * The matching criteria
     */
    where?: Where<MT>;
    /**
     * To include/exclude fields
     */
    fields?: Fields<MT>;
    /**
     * Maximum number of entities
     */
    limit?: number;
    /**
     * Sort order. Only works with sort keys
     */
    orderBy?: Direction;
    /**
     * Only be used with cursor based `query`
     */
    prevCursor?: string;
}
declare type TableIndex = {
    partitionKeyName: string;
    sortKeyName?: string;
};
export interface TableConfig {
    name: string;
    /**
     * A record of table index and it's key names
     * Required on query and get operations dealing with indexes
     * A default index is always required]
     * eg: indexes: { default: { partitionKeyName: 'pk', sortKeyName: 'sk' } }
     */
    indexes: {
        default: TableIndex;
    } & Record<string, TableIndex>;
    cursorSecret?: string;
}
export declare enum ConditionExpressionKind {
    Comparison = "comparison",
    AndOr = "AND_OR"
}
declare type ConditionExpressionItem = {
    kind: ConditionExpressionKind.Comparison;
    key: string;
    comparator: FilterOperators;
    value: string | number | boolean | Array<number>;
};
declare type AndOrExpression = {
    kind: ConditionExpressionKind.AndOr;
    value: 'AND' | 'OR';
};
export declare type ConditionExpressionInput = ConditionExpressionItem | AndOrExpression;
export interface ConditionExpressionReturn {
    expression: DocumentClient.ConditionExpression;
    attrValues: DocumentClient.ExpressionAttributeValueMap;
    attrNames: DocumentClient.ExpressionAttributeNameMap;
}
export {};