import * as pgLib from "pg";

export declare class ColName {
    static wrap(val: string): ColName;
    static unwrap(val: ColName): string;
    protected dummy: ColName;
}

export declare class TableName {
    static wrap(val: string): TableName;
    static unwrap(val: TableName): string;
    protected dummy: TableName;
}

export declare const enum Order {
    /**
     * Equivalent to [[AscNullsLast]]
     */
    Asc = 0,
    /**
     * Equivalent to [[DescNullsFirst]]
     */
    Desc = 1,
    AscNullsLast = 2,
    DescNullsFirst = 3,
    AscNullsFirst = 4,
    DescNullsLast = 5
}

export declare type MakeTable<T1 extends object, T2 extends object> = {
    [P in keyof T1]: Col<Write, T1[P]>;
} & {
    [P in keyof T2]: Col<Write, T2[P]> | DefaultValue;
};

export declare class Write {
    protected dummy: Write;
}

export declare type MakeCols<s, T extends object> = {
    [P in keyof T]: Col<s, T[P]>;
};

/**
 * Can be used in `insert` and `update` operations, to set the value
 * of a column to its default value.
 *
 * This can only be used on table columns that have been declared as
 * "default-able" when the table was declared using [[declareTable]].
 *
 * This is like using the `DEFAULT` keyword in SQL.
 */
export declare function defaultValue(): DefaultValue;

/**
 * The type of [[defaultValue]]. You cannot instantiate values of this.
 */
export declare class DefaultValue {
    protected dummy: DefaultValue;
}

export declare function count<s, a>(col: Col<s, a>): Aggr<s, number>;

export declare function avg<s>(col: Col<s, number>): Aggr<s, number | null>;

export declare function sum<s>(col: Col<s, number>): Aggr<s, number>;

export declare function max<s, a>(col: Col<s, a>): Aggr<s, a | null>;

export declare function min<s, a>(col: Col<s, a>): Aggr<s, a | null>;

export declare function inList<s, a>(lhs: Col<s, a>, rhs: Col<s, a>[]): Col<s, boolean>;

export declare class Aggr<s, a> {
    protected dummy: [Aggr<s, a>, s, a];
}

export declare class Inner<s> {
    protected dummy: [Inner<s>, s];
}

export declare type AggrCols<S, A> = {
    [P in keyof A]: Aggr<Inner<S>, A[P]>;
};

export declare type LeftCols<S, A> = {
    [P in keyof A]: Col<S, A[P] | null>;
};

export declare function declareTable<Req extends object, Def extends object>(tableName: string, columns: TableDeclareCols<Req & Def>): Table<Req, Def>;

export declare type TableDeclareCols<T extends object> = {
    [P in keyof T]: [string, (val: string) => T[P]];
};

export declare class Table<Req, Def> {
    readonly tableName: TableName;
    readonly tableCols: ColInfo[];
    protected dummy: [Table<Req, Def>, Req, Def];
}

export interface ColInfo {
    name: ColName;
    propName: string;
    parser: (val: string) => any;
}

export declare function nullCol<s>(): Col<s, null>;

export declare function numberCol<s>(val: number): Col<s, number>;

export declare function textCol<s>(str: string): Col<s, string>;

export declare function booleanCol<s>(val: boolean): Col<s, boolean>;

/**
 * A database column. A column is often a literal column table, but can also
 * be an expression over such a column or a constant expression.
 *
 * @param s Phantom type parameter. This will never have a concrete type. It
 *          is used only to enforce type safety
 *
 * @param a The type of the value that the Column contains
 */
export declare class Col<s, a> {
    protected dummy: [Col<s, a>, s, a];
}

/**
 * Perform a conditional on a column
 *
 * SQL equivalent: `CASE`
 */
export declare function ifThenElse<s, a>(if_: Col<s, boolean>, then: Col<s, a>, else_: Col<s, a>): Col<s, a>;

/**
 * Applies the given function to the given nullable column where it isn't null,
 * and returns the given default value where it is.
 *
 * @param nullable A nullable column to match against
 * @param replacement This is the value that will be returned if the nullable column is NULL
 * @param f This function will be called if the nullable column is not null, and its result will be returned
 */
export declare function matchNull<s, s2, a, b>(nullable: Col<s, a | null>, replacement: Col<s, b>, f: (col: Col<s2, a>) => Col<s2, b>): Col<s, b>;

/**
 * If the second value is null, return the first value. Otherwise return the
 * second value.
 */
export declare function ifNull<s, a>(replacement: Col<s, a>, nullable: Col<s, a | null>): Col<s, a>;

/**
 * Update rows of a table
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 * @param pred Which rows should be updated (the WHERE clause)
 * @param upd A function that returns the new values for a row.
 *
 *            You may use [[defaultValue]] on "default-able" columns.
 *
 *            Should have an explicit annotation of the return type, in order to catch excess properties.
 *            See: <https://github.com/Microsoft/TypeScript/issues/7547#issuecomment-218017839>
 * @return number of rows updated
 */
export declare function update<Req extends object, Def extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, pred: (c: MakeCols<Write, Req & Def>) => Col<Write, boolean>, upd: (c: MakeCols<Write, Req & Def>) => MakeTable<Req, Def>): Promise<number>;

/**
 * Update rows of a table, with a RETURNING clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 * @param pred Which rows should be updated (the WHERE clause)
 * @param upd A function that returns the new values for a row.
 *
 *            You may use [[defaultValue]] on "default-able" columns.
 *
 *            Should have an explicit annotation of the return type, in order to catch excess properties.
 *            See: <https://github.com/Microsoft/TypeScript/issues/7547#issuecomment-218017839>
 */
export declare function updateReturning<Req extends object, Def extends object, Ret extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, pred: (c: MakeCols<Write, Req & Def>) => Col<Write, boolean>, upd: (c: MakeCols<Write, Req & Def>) => MakeTable<Req, Def>, returning: (c: MakeCols<Write, Req & Def>) => MakeCols<Write, Ret>): Promise<Ret[]>;

/**
 * Insert a single row into a table, with a RETURNING clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function insertReturning<Req extends object, Def extends object, Ret extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>, returning: (c: MakeCols<Write, Req & Def>) => MakeCols<Write, Ret>): Promise<Ret>;

/**
 * Insert a single row into a table
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function insert<Req extends object, Def extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>): Promise<void>;

/**
 * Insert a single row into a table, with an ON CONFLICT DO NOTHING clause, and with a RETURNING clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function insertOnConflictDoNothingReturning<Req extends object, Def extends object, Ret extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>, conflictTarget: ConflictTarget<Req & Def>, returning: (c: MakeCols<Write, Req & Def>) => MakeCols<Write, Ret>): Promise<Ret>;

/**
 * Insert a single row into a table, with an ON CONFLICT DO NOTHING clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 * @return true if the row was inserted
 */
export declare function insertOnConflictDoNothing<Req extends object, Def extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>, conflictTarget: ConflictTarget<Req & Def>): Promise<boolean>;

/**
 * Insert a single row into a table, with an ON CONFLICT DO UPDATE clause, and with a RETURNING clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function insertOnConflictDoUpdateReturning<Req extends object, Def extends object, Ret extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>, conflictTarget: ConflictTarget<Req & Def>, onConflictPred: (c: MakeCols<Write, Req & Def>) => Col<Write, boolean>, onConflictUpdate: (c: MakeCols<Write, Req & Def>) => MakeTable<Req, Def>, returning: (c: MakeCols<Write, Req & Def>) => MakeCols<Write, Ret>): Promise<Ret>;

/**
 * Insert a single row into a table, with an ON CONFLICT DO UPDATE clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 * @param onConflictPred Which rows should be updated (the WHERE clause)
 *
 * @param onConflictUpdate A function that returns the new values for a row.
 *
 *                         You may use [[defaultValue]] on "default-able" columns.
 *
 *                         Should have an explicit annotation of the return type, in order to catch excess properties.
 *                         See: <https://github.com/Microsoft/TypeScript/issues/7547#issuecomment-218017839>
 *
 * @return If a new row was inserted returns true.
 *
 *         If a conflicting row already existed but was updated returns true.
 *
 *         If a conflicting row already existed and was not updated returns false.
 */
export declare function insertOnConflictDoUpdate<Req extends object, Def extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>, conflictTarget: ConflictTarget<Req & Def>, onConflictPred: (c: MakeCols<Write, Req & Def>) => Col<Write, boolean>, onConflictUpdate: (c: MakeCols<Write, Req & Def>) => MakeTable<Req, Def>): Promise<boolean>;

/**
 * Insert multiple rows into a table, with a RETURNING clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function insertManyReturning<Req extends object, Def extends object, Ret extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>[], returning: (c: MakeCols<Write, Req & Def>) => MakeCols<Write, Ret>): Promise<Ret[]>;

/**
 * Insert multiple rows into a table
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function insertMany<Req extends object, Def extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>[]): Promise<void>;

/**
 * Insert multiple rows into a table, with an ON CONFLICT DO NOTHING clause, and with a RETURNING clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function insertManyOnConflictDoNothingReturning<Req extends object, Def extends object, Ret extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>[], conflictTarget: ConflictTarget<Req & Def>, returning: (c: MakeCols<Write, Req & Def>) => MakeCols<Write, Ret>): Promise<Ret[]>;

/**
 * Insert multiple rows into a table, with an ON CONFLICT DO NOTHING clause
 *
 * @return The number of rows inserted
 */
export declare function insertManyOnConflictDoNothing<Req extends object, Def extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>[], conflictTarget: ConflictTarget<Req & Def>): Promise<number>;

/**
 * Insert multiple rows into a table, with an ON CONFLICT DO UPDATE clause, and with a RETURNING clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function insertManyOnConflictDoUpdateReturning<Req extends object, Def extends object, Ret extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>[], conflictTarget: ConflictTarget<Req & Def>, onConflictPred: (c: MakeCols<Write, Req & Def>) => Col<Write, boolean>, onConflictUpdate: (c: MakeCols<Write, Req & Def>) => MakeTable<Req, Def>, returning: (c: MakeCols<Write, Req & Def>) => MakeCols<Write, Ret>): Promise<Ret[]>;

/**
 * Insert multiple rows into a table, with an ON CONFLICT DO UPDATE clause
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 * @param onConflictPred Which rows should be updated (the WHERE clause)
 *
 * @param onConflictUpdate A function that returns the new values for a row.
 *
 *                         You may use [[defaultValue]] on "default-able" columns.
 *
 *                         Should have an explicit annotation of the return type, in order to catch excess properties.
 *                         See: <https://github.com/Microsoft/TypeScript/issues/7547#issuecomment-218017839>
 *
 * @return The number of newly inserted rows + the number of updated rows
 */
export declare function insertManyOnConflictDoUpdate<Req extends object, Def extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, rowValues: MakeTable<Req, Def>[], conflictTarget: ConflictTarget<Req & Def>, onConflictPred: (c: MakeCols<Write, Req & Def>) => Col<Write, boolean>, onConflictUpdate: (c: MakeCols<Write, Req & Def>) => MakeTable<Req, Def>): Promise<number>;

/**
 * Delete rows of a table
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 * @param pred Which rows should be deleted (the WHERE clause)
 * @return number of rows deleted
 */
export declare function delete_<Req extends object, Def extends object>(sqlTag: string | undefined, conn: pg.Client, table: Table<Req, Def>, pred: (c: MakeCols<Write, Req & Def>) => Col<Write, boolean>): Promise<number>;

export declare class ConflictTarget<Cols> {
    static tableColumns<Cols>(cols: (keyof Cols)[]): ConflictTarget<Cols>;
    protected dummy: [ConflictTarget<Cols>, Cols];
}

export declare namespace pg {
    type Client = pgLib.Client;
    /**
     * Connect to a PostgreSQL database. You should call `closePg` when you are done.
     *
     * @param connection A PostgreSQL connection string, such as:
     *                   "postgres://myuser:mypassword@localhost:5432/dbname"
     */
    function connectPg(connection: string): Promise<Client>;
    function closePg(conn: Client): Promise<void>;
    /**
     *
     * @param connection See `connectPg`
     * @param action
     */
    function withPg<A>(connection: string, action: (conn: Client) => Promise<A>): Promise<A>;
    function query_(conn: Client, queryText: string): Promise<void>;
    function query(conn: Client, queryText: string, values: any[]): Promise<pgLib.QueryResult>;
}

/**
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function query<t extends object>(sqlTag: string | undefined, conn: pg.Client, q: (q: Q<{}>) => MakeCols<{}, t>): Promise<t[]>;

/**
 * Similar to [[query]], but when you are certain that the query will always return
 * exactly 1 row.
 *
 * For example: COUNT(*) style queries
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function queryOne<t extends object>(sqlTag: string | undefined, conn: pg.Client, q: (q: Q<{}>) => MakeCols<{}, t>): Promise<t>;

/**
 * Similar to [[query]], but when you are certain that the query will always return
 * either 1 row or 0 rows.
 *
 * For example: queries that are restricted on some primary key
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 */
export declare function queryOneOrNone<t extends object>(sqlTag: string | undefined, conn: pg.Client, q: (q: Q<{}>) => MakeCols<{}, t>): Promise<t | null>;

/**
 * Perform a query, but stream the results rather than loading them all into
 * memory.
 *
 * After you call this function, you *must* call the `readAllRows` function, and
 * you must call it while the connection is still open (and don't close the
 * connection until it completes).
 *
 * @param sqlTag Will be injected as a comment into the SQL that is sent to the server. Useful for identifying the query during log analysis and performance analysis
 * @param rowChunkSize How many rows to read and process during each iteration
 */
export declare function queryStreaming<t extends object>(sqlTag: string | undefined, conn: pg.Client, q: (q: Q<{}>) => MakeCols<{}, t>, rowChunkSize?: number): Promise<StreamingRows<t>>;

export declare function restrict<s>(q: Q<s>, expr: Col<s, boolean>): void;

export declare function groupBy<s, a>(q: Q<Inner<s>>, col: Col<Inner<s>, a>): Aggr<Inner<s>, a>;

export declare function aggregate<s, a extends object>(q: Q<s>, s: (q: Q<Inner<s>>) => AggrCols<s, a>): MakeCols<s, a>;

export declare function inQuery<s, a>(lhs: Col<s, a>, rhs: (q: Q<s>) => Col<s, a>): Col<s, boolean>;

/**
 * Does the subquery have at least one row?
 *
 * SQL equivalent: EXISTS
 *
 * @param subquery The subquery should return [[arbitrary]] (since the values,
 *                 of the resulting rows in unimportant).
 */
export declare function exists<s>(subquery: (q: Q<s>) => Col<s, Arbitrary>): Col<s, boolean>;

/**
 * The type of an [[arbitrary]] column
 */
export declare class Arbitrary {
    protected dummy: Arbitrary;
}

/**
 * An arbitrary column, useful for queries where the values of the returned
 * rows are not important, such as in [[exists]] queries.
 */
export declare function arbitrary<s>(): Col<s, Arbitrary>;

export declare function leftJoin<s, a extends object>(q: Q<s>, s: (q: Q<Inner<s>>) => MakeCols<Inner<s>, a>, pred: (p: MakeCols<s, a>) => Col<s, boolean>): LeftCols<s, a>;

export declare function innerJoin<s, a extends object>(q: Q<s>, s: (q: Q<Inner<s>>) => MakeCols<Inner<s>, a>, pred: (p: MakeCols<s, a>) => Col<s, boolean>): MakeCols<s, a>;

/**
 * Explicitly create an inner query.
 *
 * Sometimes it's handy, for performance reasons and otherwise, to perform a
 * subquery and restrict only that query before adding the result of the
 * query to the result set, instead of first adding the query to the result
 * set and restricting the whole result set afterwards.
 */
export declare function inner<s, a extends object>(q: Q<s>, query: (q: Q<Inner<s>>) => MakeCols<Inner<s>, a>): MakeCols<s, a>;

/**
 * Create and filter an inner query, before adding it to the current result
 * set.
 *
 * `suchThat(q, query, p)`
 * is generally more efficient than
 * `const x = query(q); restrict(pred(x)); return x;`
 */
export declare function suchThat<s, a extends object>(q: Q<s>, query: (q: Q<Inner<s>>) => MakeCols<Inner<s>, a>, pred: (row: MakeCols<Inner<s>, a>) => Col<Inner<s>, boolean>): MakeCols<s, a>;

export declare function select<s, a extends object, b extends object>(q: Q<s>, table: Table<a, b>): MakeCols<s, a & b>;

/**
 * Query an ad hoc table. Each element in the given list represents one row
 * in the ad hoc table.
 */
export declare function selectValues<s, a extends object>(q: Q<s>, vals: MakeCols<s, a>[]): MakeCols<s, a>;

export declare function limit<s, a extends object>(q: Q<s>, from: number, to: number, query: (q: Q<Inner<s>>) => MakeCols<Inner<s>, a>): MakeCols<s, a>;

export declare function order<s, a>(q: Q<s>, col: Col<s, a>, order: Order): void;

export declare function distinct<s, a extends object>(q: Q<s>, query: (q: Q<s>) => MakeCols<s, a>): MakeCols<s, a>;

export declare class Q<s> {
    protected dummy: [Q<s>, s];
}

/**
 * Will be thrown during a query, if parsing of a column fails for any of the returned rows
 */
export declare class ColumnParseError extends Error {
    readonly query: string;
    readonly columnValue: string;
    readonly parseFunction: string;
    readonly innerError: Error | undefined;
    protected __proto__: Error;
    constructor(message: string, query: string, columnValue: string, parseFunction: string, innerError?: Error);
}

/**
 * Is the given column null?
 *
 * This is like SQL's `IS NULL` check
 */
export declare function isNull<s, a>(col: Col<s, a | null>): Col<s, boolean>;

/**
 * Is the given column not null?
 *
 * This is like SQL's `IS NOT NULL` check
 *
 * `isNotNull(c)` is equivalent to `not(isNull(c))`
 */
export declare function isNotNull<s, a>(col: Col<s, a | null>): Col<s, boolean>;

/**
 * Boolean negation.
 *
 * This is like SQL's `NOT` operator
 */
export declare function not<s, a>(col: Col<s, a | null>): Col<s, boolean>;

/**
 * A shortcut that calls `restrict` comparing two columns for equality.
 *
 * `restrictEq(q, x, y)` is equivalent to `restrict(q, e(x, "=", y))`
 */
export declare function restrictEq<s, a>(q: Q<s>, lhs: Col<s, a>, rhs: Col<s, a>): void;

/**
 * Returns true if the string matches the supplied pattern
 *
 * SQL equivalent: `LIKE`
 *
 * @param str The string to be matched against
 * @param pattern The pattern to use. May use special characters '%' and '_'
 */
export declare function like<s>(str: Col<s, string>, pattern: string): Col<s, boolean>;

/**
 * Returns true if the string matches the supplied pattern
 *
 * SQL equivalent: `LIKE`
 *
 * @param str The string to be matched against
 * @param pattern The pattern to use. May use special characters '%' and '_'
 */
export declare function like<s>(str: Col<s, string>, pattern: Col<s, string>): Col<s, boolean>;

/**
 * Returns true if the string matches the supplied pattern, using case-insensitive matching
 *
 * SQL equivalent: `ILIKE`
 *
 * @param str The string to be matched against
 * @param pattern The pattern to use. May use special characters '%' and '_'
 */
export declare function ilike<s>(str: Col<s, string>, pattern: string): Col<s, boolean>;

/**
 * Returns true if the string matches the supplied pattern, using case-insensitive matching
 *
 * SQL equivalent: `ILIKE`
 *
 * @param str The string to be matched against
 * @param pattern The pattern to use. May use special characters '%' and '_'
 */
export declare function ilike<s>(str: Col<s, string>, pattern: Col<s, string>): Col<s, boolean>;

export declare function e<s, a>(lhs: Col<s, a>, op: "=", rhs: Col<s, a>): Col<s, boolean>;

export declare function e<s, a>(lhs: Col<s, a>, op: "!=", rhs: Col<s, a>): Col<s, boolean>;

export declare function e<s, a>(lhs: Col<s, a>, op: ">", rhs: Col<s, a>): Col<s, boolean>;

export declare function e<s, a>(lhs: Col<s, a>, op: "<", rhs: Col<s, a>): Col<s, boolean>;

export declare function e<s, a>(lhs: Col<s, a>, op: ">=", rhs: Col<s, a>): Col<s, boolean>;

export declare function e<s, a>(lhs: Col<s, a>, op: "<=", rhs: Col<s, a>): Col<s, boolean>;

export declare function e<s>(lhs: Col<s, boolean>, op: "AND", rhs: Col<s, boolean>): Col<s, boolean>;

export declare function e<s>(lhs: Col<s, boolean>, op: "OR", rhs: Col<s, boolean>): Col<s, boolean>;

export declare function e<s>(lhs: Col<s, number>, op: "+", rhs: Col<s, number>): Col<s, number>;

export declare function e<s>(lhs: Col<s, number>, op: "-", rhs: Col<s, number>): Col<s, number>;

export declare function e<s>(lhs: Col<s, number>, op: "*", rhs: Col<s, number>): Col<s, number>;

export declare function e<s>(lhs: Col<s, number>, op: "/", rhs: Col<s, number>): Col<s, number>;

export declare function e<s>(lhs: Col<s, string>, op: "||", rhs: Col<s, string>): Col<s, string>;

/**
 * Logs generated SQL strings and execution timing metrics
 */
export declare namespace Debug {
    function enableDebug(): void;
    function disableDebug(): void;
    function debugEnabled(): boolean;
    class QueryMetrics {
        protected querySQL_: string;
        protected stage1BeforeCompileQuery: [number, number];
        protected stage2BeforeCompileSql: [number, number];
        protected stage3BeforeRunQuery: [number, number];
        protected stage4BeforeParseQueryResults: [number, number];
        protected stage5End: [number, number];
        querySQL(): string;
        compileQueryTime(): number;
        compileSqlTime(): number;
        runQueryTime(): number;
        parseQueryResultsTime(): number;
        totalTime(): number;
    }
    function getLastQueryMetrics(conn: pg.Client): QueryMetrics;
}

export declare namespace SqlType {
    function intParser(val: string): number;
    function numberParser(val: string): number;
    function stringParser(val: string): string;
    function booleanParser(val: string): boolean;
}
export interface StreamingRows<T> {
    /**
     * Read in all of the results, the callback will be called multiple times,
     * each time with a new batch of results.
     */
    readAllRows(action: (results: T[]) => Promise<void>): Promise<void>;
}

export declare namespace Unsafe {
    /**
     * Perform a runtime cast of a column to a specified SQL type
     *
     * @param sqlType The SQL type, such as `BIGINT`
     */
    function unsafeCast<s, a, b>(col: Col<s, a>, sqlType: string, parser: (val: string) => b): Col<s, b>;
    /**
     * A unary operation. Note that the provided function name is spliced directly
     * into the resulting SQL query. Thus, this function should ONLY be used to
     * implement well-defined functions that are missing from Zol's standard library,
     * and NOT in an ad hoc manner during queries.
     *
     * @param funName Name of the SQL function
     * @param col Argument to the function
     * @param parser Function that parses the raw SQL value into the return type of the function
     */
    function unsafeFun<s, a, b>(funName: string, col: Col<s, a>, parser: (val: string) => b): Col<s, b>;
    /**
     * Like [[unsafeFun]], but with two arguments.
     *
     * @param funName Name of the SQL function
     * @param col1 First argument to the function
     * @param col2 Second argument to the function
     * @param parser Function that parses the raw SQL value into the return type of the function
     */
    function unsafeFun2<s, a, b, c>(funName: string, col1: Col<s, a>, col2: Col<s, b>, parser: (val: string) => c): Col<s, c>;
    /**
     * Like [[unsafeFun]], but with three arguments.
     *
     * @param funName Name of the SQL function
     * @param col1 First argument to the function
     * @param col2 Second argument to the function
     * @param col3 Third argument to the function
     * @param parser Function that parses the raw SQL value into the return type of the function
     */
    function unsafeFun3<s, a, b, c, d>(funName: string, col1: Col<s, a>, col2: Col<s, b>, col3: Col<s, c>, parser: (val: string) => d): Col<s, d>;
    /**
     * Like [[unsafeFun]], but with an arbitrary number of arguments.
     *
     * @param funName Name of the SQL function
     * @param cols Arguments to the function
     * @param parser Function that parses the raw SQL value into the return type of the function
     */
    function unsafeFunN<s, a>(funName: string, cols: Col<s, any>[], parser: (val: string) => a): Col<s, a>;
    /**
     * Create a named aggregate function. Like [[unsafeFun]], this function is generally
     * unsafe and should ONLY be used to implement missing backend-specific
     * functionality.
     *
     * @param funName Name of the SQL function
     * @param col Argument to the function
     * @param parser Function that parses the raw SQL value into the return type of the function
     */
    function unsafeAggr<s, a, b>(funName: string, col: Col<s, a>, parser: (val: string) => b): Aggr<s, b>;
    function unsafeBinOp<s, a, b, c>(opName: string, lhs: Col<s, a>, rhs: Col<s, b>, parser: (val: string) => c): Col<s, c>;
    /**
     * This is very unsafe. Can easily lead to SQL injections if used without care
     *
     * @param fragments
     * @param parser
     */
    function unsafeRaw<s, a>(fragments: (string | Col<s, any>)[], parser: (val: string) => a): Col<s, a>;
}