@types/pg

constructor(config?: string | ClientConfig);

database?: string;

host: string;

password?: string;

port: number;

ssl: boolean;

user?: string;

end: { (): Promise<void>; (callback: (err: Error) => void): void };

constructor(config?: string | ClientConfig);

escapeIdentifier: (str: string) => string;

escapeLiteral: (str: string) => string;

getTypeParser: any;

setTypeParser: any;

connect: { (): Promise<void>; (callback: (err: Error) => void): void };

copyFrom: (queryText: string) => stream.Writable;

copyTo: (queryText: string) => stream.Readable;

on: {
    (event: 'drain', listener: () => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'notice', listener: (notice: NoticeMessage) => void): this;
    (event: 'notification', listener: (message: Notification) => void): this;
    (event: 'end', listener: () => void): this;
};

pauseDrain: () => void;

query: {
    <T extends Submittable>(queryStream: T): T;
    <R extends any[] = any[], I = any[]>(
        queryConfig: QueryArrayConfig<I>,
        values?: QueryConfigValues<I>
    ): Promise<QueryArrayResult<R>>;
    <R extends QueryResultRow = any, I = any>(
        queryConfig: QueryConfig<I>
    ): Promise<QueryResult<R>>;
    <R extends QueryResultRow = any, I = any[]>(
        queryTextOrConfig: string | QueryConfig<I>,
        values?: QueryConfigValues<I>
    ): Promise<QueryResult<R>>;
    <R extends any[] = any[], I = any[]>(
        queryConfig: QueryArrayConfig<I>,
        callback: (err: Error, result: QueryArrayResult<R>) => void
    ): void;
    <R extends QueryResultRow = any, I = any[]>(
        queryTextOrConfig: string | QueryConfig<I>,
        callback: (err: Error, result: QueryResult<R>) => void
    ): void;
    <R extends QueryResultRow = any, I = any[]>(
        queryText: string,
        values: QueryConfigValues<I>,
        callback: (err: Error, result: QueryResult<R>) => void
    ): void;
};

resumeDrain: () => void;

constructor(config?: ClientConfig);

readonly stream: stream.Duplex;

bind: (config: BindConfig | null, more: boolean) => void;

close: (msg: MessageConfig, more: boolean) => void;

describe: (msg: MessageConfig, more: boolean) => void;

end: () => void;

execute: (config: ExecuteConfig | null, more: boolean) => void;

flush: () => void;

parse: (query: QueryParse, more: boolean) => void;

query: (text: string) => void;

sync: () => void;

on: (event: 'error', listener: (err: Error, client: Client) => void) => this;

constructor(config?: PoolConfig);

readonly ended: boolean;

readonly ending: boolean;

readonly expiredCount: number;

readonly idleCount: number;

options: PoolOptions;

readonly totalCount: number;

readonly waitingCount: number;

connect: {
    (): Promise<PoolClient>;
    (
        callback: (
            err: Error,
            client: PoolClient,
            done: (release?: any) => void
        ) => void
    ): void;
};

end: { (): Promise<void>; (callback: () => void): void };

on: {
    (
        event: 'release' | 'error',
        listener: (err: Error, client: PoolClient) => void
    ): this;
    (
        event: 'connect' | 'acquire' | 'remove',
        listener: (client: PoolClient) => void
    ): this;
};

query: {
    <T extends Submittable>(queryStream: T): T;
    <R extends any[] = any[], I = any[]>(
        queryConfig: QueryArrayConfig<I>,
        values?: QueryConfigValues<I>
    ): Promise<QueryArrayResult<R>>;
    <R extends QueryResultRow = any, I = any[]>(
        queryConfig: QueryConfig<I>
    ): Promise<QueryResult<R>>;
    <R extends QueryResultRow = any, I = any[]>(
        queryTextOrConfig: string | QueryConfig<I>,
        values?: QueryConfigValues<I>
    ): Promise<QueryResult<R>>;
    <R extends any[] = any[], I = any[]>(
        queryConfig: QueryArrayConfig<I>,
        callback: (err: Error, result: QueryArrayResult<R>) => void
    ): void;
    <R extends QueryResultRow = any, I = any[]>(
        queryTextOrConfig: string | QueryConfig<I>,
        callback: (err: Error, result: QueryResult<R>) => void
    ): void;
    <R extends QueryResultRow = any, I = any[]>(
        queryText: string,
        values: QueryConfigValues<I>,
        callback: (err: Error, result: QueryResult<R>) => void
    ): void;
};

constructor(queryTextOrConfig?: string | QueryConfig<I>, values?: any[]);

submit: (connection: Connection) => void;

on: {
    (event: 'row', listener: (row: R, result?: ResultBuilder<R>) => void): this;
    (event: 'error', listener: (err: Error) => void): this;
    (event: 'end', listener: (result: ResultBuilder<R>) => void): this;
};

binary?: string | undefined;

portal?: string | undefined;

statement?: string | undefined;

valueMapper?: ValueMapper | undefined;

values?: Array<Buffer | null | undefined | string> | undefined;

application_name?: string | undefined;

connectionString?: string | undefined;

connectionTimeoutMillis?: number | undefined;

database?: string | undefined;

host?: string | undefined;

idle_in_transaction_session_timeout?: number | undefined;

keepAlive?: boolean | undefined;

keepAliveInitialDelayMillis?: number | undefined;

lock_timeout?: number | undefined;

options?: string | undefined;

password?: string | (() => string | Promise<string>) | undefined;

port?: number | undefined;

query_timeout?: number | undefined;

ssl?: boolean | ConnectionOptions | undefined;

statement_timeout?: false | number | undefined;

stream?: () => stream.Duplex | stream.Duplex | undefined;

types?: CustomTypesConfig | undefined;

user?: string | undefined;

getTypeParser: typeof pgTypes.getTypeParser;

binary?: boolean | undefined;

parseInputDatesAsUTC?: boolean | undefined;

parseInt8?: boolean | undefined;

poolIdleTimeout?: number | undefined;

poolSize?: number | undefined;

reapIntervalMillis?: number | undefined;

portal?: string | undefined;

rows?: string | undefined;

columnID: number;

dataTypeID: number;

dataTypeModifier: number;

dataTypeSize: number;

format: string;

name: string;

tableID: number;

name?: string | undefined;

type: string;

channel: string;

payload?: string | undefined;

processId: number;

release: (err?: Error | boolean) => void;

allowExitOnIdle?: boolean | undefined;

Client?: (new () => ClientBase) | undefined;

idleTimeoutMillis?: number | undefined | null;

log?: ((...messages: any[]) => void) | undefined;

max?: number | undefined;

maxLifetimeSeconds?: number | undefined;

maxUses?: number | undefined;

min?: number | undefined;

Promise?: PromiseConstructorLike | undefined;

allowExitOnIdle: boolean;

idleTimeoutMillis: number | null;

max: number;

maxLifetimeSeconds: number;

maxUses: number;

rowMode: 'array';

rows: R[];

name?: string | undefined;

text: string;

types?: CustomTypesConfig | undefined;

values?: QueryConfigValues<I>;

name: string;

text: string;

types: string[];

rows: R[];

command: string;

fields: FieldDef[];

oid: number;

rowCount: number | null;

[column: string]: any;

addRow: (row: R) => void;

submit: (connection: Connection) => void;