/**
 * Representation of a single value
 *
 * @export
 * @class Value
 */
declare class Value {
    readonly value: unknown;
    protected static cache: Map<unknown, Value>;
    /**
     * Creates an instance of Value
     *
     * @param {unknown} value
     * @memberof Value
     */
    constructor(value: unknown);
    /**
     * Create (or re-use) a Value instance representing a value
     *
     * @static
     * @param {unknown} value
     * @returns {Value}
     * @memberof Value
     */
    static from(value: unknown): Value;
}

/**
 * interleave TemplateLiteral arguments into a single list of Value instances
 *
 * @export
 * @param {TemplateStringsArray} strings
 * @param {...Array<unknown>} values
 * @returns {Array<Value>}
 */
declare function interleave(strings: TemplateStringsArray, ...values: Array<unknown>): Array<Value>;

type FilterFunction = (...args: Array<unknown>) => boolean;

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>}
 */
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>}
 */
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>}
 */
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>}
 */
declare function mapper<T extends Item>(mapper: Partial<Mapper<T>>): TableOf<T>;

export { create, empty, mapper, table };