import { interleave } from './Collection';
import { FilterFunction } from './Filters';
type Item = {
    [key: string]: unknown;
};
type MapperFunction<T = unknown> = (value: T | string | unknown) => T;
type Mapper<T extends Item> = {
    [K in keyof T]: MapperFunction<T[K]>;
};
type Params = Parameters<typeof interleave>;
type Table = {
    <T extends Item = Item>(...args: Params): Array<T>;
};
type TableOf<T extends Item> = {
    (...args: Params): Array<T>;
};
/**
 * Create a new template literal function parsing tables with a custom set of filters
 *
 * @export
 * @param {...Array<Filter>} filters
 * @returns {(...args: Params) => Array<Item>}
 */
export declare function create(...filters: Array<FilterFunction>): (...args: Params) => Array<Item>;
/**
 * Table template literal parser, exludes any divider ro, preserves rows
 * consisting of only undefined values
 *
 *
 * @template T
 * @param {TemplateStringsArray} strings
 * @param {...Array<unknown>} values
 * @returns {Array<T>}
 */
export declare const empty: Table;
/**
 * Table template literal parser, exludes both any divider row and
 * rows that contain only undefined values
 *
 * @template T
 * @param {TemplateStringsArray} strings
 * @param {...Array<unknown>} values
 * @returns {Array<T>}
 */
export declare const table: Table & {
    empty: Table;
};
/**
 * Create a new table template literaral parser, mapping specified keys
 *
 * @export
 * @template T
 * @param {Mapper<T>} mapper
 * @return {Table<T>}
 */
export declare function mapper<T extends Item>(mapper: Partial<Mapper<T>>): TableOf<T>;
export {};