@tsonic/efcore-npgsql 0.1.1

package/Npgsql/internal/index.d.ts

@@ -0,0 +1,1619 @@
+// Generated by tsbindgen - Architecture
+// Namespace: Npgsql
+// Assembly: Npgsql
+
+// Primitive type aliases from @tsonic/core
+import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';
+
+// Import support types from @tsonic/core
+import type { ptr } from "@tsonic/core/types.js";
+
+// Import types from other namespaces
+import type { DbTypeResolverFactory, PgTypeInfoResolverFactory } from "../../Npgsql.Internal/internal/index.js";
+import type { PostgresType } from "../../Npgsql.PostgresTypes/internal/index.js";
+import type { NpgsqlDbColumn } from "../../Npgsql.Schema/internal/index.js";
+import * as Npgsql_TypeMapping_Internal from "../../Npgsql.TypeMapping/internal/index.js";
+import type { INpgsqlTypeMapper } from "../../Npgsql.TypeMapping/internal/index.js";
+import type { NpgsqlDbType } from "../../NpgsqlTypes/internal/index.js";
+import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic.js";
+import type { ICollection as ICollection__System_Collections_Generic, IDictionary as IDictionary__System_Collections_Generic, IEnumerable as IEnumerable__System_Collections_Generic, IEnumerator as IEnumerator__System_Collections_Generic, IList as IList__System_Collections_Generic, IReadOnlyDictionary, IReadOnlyList, KeyValuePair } from "@tsonic/dotnet/System.Collections.Generic.js";
+import * as System_Collections_Internal from "@tsonic/dotnet/System.Collections.js";
+import type { ICollection, IDictionary, IEnumerable, IEnumerator, IList } from "@tsonic/dotnet/System.Collections.js";
+import type { ReadOnlyCollection } from "@tsonic/dotnet/System.Collections.ObjectModel.js";
+import * as System_ComponentModel_Internal from "@tsonic/dotnet/System.ComponentModel.js";
+import type { IComponent, ICustomTypeDescriptor } from "@tsonic/dotnet/System.ComponentModel.js";
+import * as System_Data_Common_Internal from "@tsonic/dotnet/System.Data.Common.js";
+import type { DataTableMapping, DbBatch, DbBatchCommand, DbBatchCommandCollection, DbColumn, DbCommand, DbCommandBuilder, DbConnection, DbConnectionStringBuilder, DbDataAdapter, DbDataReader, DbDataSource, DbException, DbParameter, DbParameterCollection, DbProviderFactory, DbTransaction, IDbColumnSchemaGenerator, RowUpdatedEventArgs, RowUpdatingEventArgs } from "@tsonic/dotnet/System.Data.Common.js";
+import * as System_Data_Internal from "@tsonic/dotnet/System.Data.js";
+import type { CommandBehavior, CommandType, ConnectionState, DataRow, DataRowVersion, DataTable, DbType, IDataAdapter, IDataParameter, IDataParameterCollection, IDataReader, IDataRecord, IDbCommand, IDbConnection, IDbDataAdapter, IDbDataParameter, IDbTransaction, IsolationLevel, ParameterDirection, StatementType as StatementType_Data, UpdateRowSource } from "@tsonic/dotnet/System.Data.js";
+import type { Activity } from "@tsonic/dotnet/System.Diagnostics.js";
+import * as System_IO_Internal from "@tsonic/dotnet/System.IO.js";
+import type { SeekOrigin, Stream, StreamReader, StreamWriter, TextReader } from "@tsonic/dotnet/System.IO.js";
+import * as System_Internal from "@tsonic/dotnet/System.js";
+import type { Action, Array as ClrArray, AsyncCallback, Boolean as ClrBoolean, Byte, Char, DateTime, Decimal, Double, Enum, EventArgs, EventHandler, Exception, Func, Guid, IAsyncDisposable, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormattable, Int16, Int32, Int64, IntPtr, IServiceProvider, ISpanFormattable, Memory, MulticastDelegate, Nullable, Object as ClrObject, ReadOnlyMemory, ReadOnlySpan, Single, Span, String as ClrString, TimeSpan, Type, UInt32, UInt64, ValueType, Version, Void } from "@tsonic/dotnet/System.js";
+import type { NegotiateAuthenticationClientOptions, RemoteCertificateValidationCallback, SslClientAuthenticationOptions } from "@tsonic/dotnet/System.Net.Security.js";
+import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization.js";
+import type { ISerializable, SerializationInfo, StreamingContext } from "@tsonic/dotnet/System.Runtime.Serialization.js";
+import type { X509Certificate, X509Certificate2, X509Certificate2Collection, X509CertificateCollection } from "@tsonic/dotnet/System.Security.Cryptography.X509Certificates.js";
+import type { JsonSerializerOptions } from "@tsonic/dotnet/System.Text.Json.js";
+import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
+import type { Task, ValueTask } from "@tsonic/dotnet/System.Threading.Tasks.js";
+import type { Transaction } from "@tsonic/dotnet/System.Transactions.js";
+import type { ILoggerFactory } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging.js";
+
+export enum ArrayNullabilityMode {
+    never_ = 0,
+    always = 1,
+    perInstance = 2
+}
+
+
+export enum ChannelBinding {
+    disable = 0,
+    prefer = 1,
+    require = 2
+}
+
+
+export enum GssEncryptionMode {
+    disable = 0,
+    prefer = 1,
+    require = 2
+}
+
+
+export enum ServerCompatibilityMode {
+    none = 0,
+    redshift = 1,
+    noTypeLoading = 2
+}
+
+
+export enum SslMode {
+    disable = 0,
+    allow = 1,
+    prefer = 2,
+    require = 3,
+    verifyCA = 4,
+    verifyFull = 5
+}
+
+
+export enum SslNegotiation {
+    postgres = 0,
+    direct = 1
+}
+
+
+export enum StatementType {
+    unknown_ = 0,
+    select = 1,
+    insert = 2,
+    delete_ = 3,
+    update = 4,
+    createTableAs = 5,
+    move = 6,
+    fetch = 7,
+    copy = 8,
+    other = 9,
+    merge = 10,
+    call = 11
+}
+
+
+export enum TargetSessionAttributes {
+    any_ = 0,
+    readWrite = 1,
+    readOnly = 2,
+    primary = 3,
+    standby = 4,
+    preferPrimary = 5,
+    preferStandby = 6
+}
+
+
+export type NoticeEventHandler = (sender: unknown, e: NpgsqlNoticeEventArgs) => void;
+
+
+export type NotificationEventHandler = (sender: unknown, e: NpgsqlNotificationEventArgs) => void;
+
+
+export type NpgsqlRowUpdatedEventHandler = (sender: unknown, e: NpgsqlRowUpdatedEventArgs) => void;
+
+
+export type NpgsqlRowUpdatingEventHandler = (sender: unknown, e: NpgsqlRowUpdatingEventArgs) => void;
+
+
+export type ProvideClientCertificatesCallback = (certificates: X509CertificateCollection) => void;
+
+
+export type ProvidePasswordCallback = (host: string, port: int, database: string, username: string) => string;
+
+
+export interface INpgsqlNameTranslator$instance {
+    translateTypeName(clrName: string): string;
+}
+
+
+export type INpgsqlNameTranslator = INpgsqlNameTranslator$instance;
+
+export interface NpgsqlBatch$instance extends DbBatch {
+    readonly batchCommands: NpgsqlBatchCommandCollection;
+    get connection(): NpgsqlConnection | undefined;
+    set connection(value: NpgsqlConnection);
+    enableErrorBarriers: boolean;
+    timeout: int;
+    get transaction(): NpgsqlTransaction | undefined;
+    set transaction(value: NpgsqlTransaction);
+    cancel(): void;
+    createBatchCommand(): NpgsqlBatchCommand;
+    dispose(): void;
+    executeNonQuery(): int;
+    executeNonQueryAsync(cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
+    executeReader(behavior?: CommandBehavior): NpgsqlDataReader;
+    executeReaderAsync(cancellationToken?: CancellationToken): Task<NpgsqlDataReader>;
+    executeReaderAsync(behavior: CommandBehavior, cancellationToken?: CancellationToken): Task<NpgsqlDataReader>;
+    executeScalar(): unknown | undefined;
+    executeScalarAsync(cancellationToken?: CancellationToken): Task<unknown | undefined>;
+    prepare(): void;
+    prepareAsync(cancellationToken?: CancellationToken): Task;
+}
+
+
+export const NpgsqlBatch: {
+    new(connection: NpgsqlConnection, transaction: NpgsqlTransaction): NpgsqlBatch;
+};
+
+
+export type NpgsqlBatch = NpgsqlBatch$instance;
+
+export interface NpgsqlBatchCommand$instance extends DbBatchCommand {
+    appendErrorBarrier: Nullable<System_Internal.Boolean>;
+    readonly canCreateParameter: boolean;
+    commandText: string;
+    commandType: CommandType;
+    readonly OID: uint;
+    readonly parameters: NpgsqlParameterCollection;
+    readonly recordsAffected: int;
+    readonly rows: ulong;
+    readonly statementType: StatementType;
+    createParameter(): NpgsqlParameter;
+    toString(): string;
+}
+
+
+export const NpgsqlBatchCommand: {
+    new(): NpgsqlBatchCommand;
+    new(commandText: string): NpgsqlBatchCommand;
+};
+
+
+export type NpgsqlBatchCommand = NpgsqlBatchCommand$instance;
+
+export interface NpgsqlBatchCommandCollection$instance extends DbBatchCommandCollection {
+    readonly count: int;
+    readonly isReadOnly: boolean;
+    item: NpgsqlBatchCommand;
+    add(item: NpgsqlBatchCommand): void;
+    add(item: DbBatchCommand): void;
+    clear(): void;
+    contains(item: NpgsqlBatchCommand): boolean;
+    contains(item: DbBatchCommand): boolean;
+    copyTo(array: NpgsqlBatchCommand[], arrayIndex: int): void;
+    copyTo(array: DbBatchCommand[], arrayIndex: int): void;
+    getEnumerator(): IEnumerator__System_Collections_Generic<DbBatchCommand>;
+    indexOf(item: NpgsqlBatchCommand): int;
+    indexOf(item: DbBatchCommand): int;
+    insert(index: int, item: NpgsqlBatchCommand): void;
+    insert(index: int, item: DbBatchCommand): void;
+    remove(item: NpgsqlBatchCommand): boolean;
+    remove(item: DbBatchCommand): boolean;
+    removeAt(index: int): void;
+}
+
+
+export const NpgsqlBatchCommandCollection: {
+    new(): NpgsqlBatchCommandCollection;
+};
+
+
+export type NpgsqlBatchCommandCollection = NpgsqlBatchCommandCollection$instance;
+
+export interface NpgsqlBinaryExporter$instance {
+    readonly isNull: boolean;
+    timeout: TimeSpan;
+    cancel(): void;
+    cancelAsync(): Task;
+    dispose(): void;
+    disposeAsync(): ValueTask;
+    read<T>(): T;
+    read<T>(type_: NpgsqlDbType): T;
+    readAsync<T>(cancellationToken?: CancellationToken): ValueTask<T>;
+    readAsync<T>(type_: NpgsqlDbType, cancellationToken?: CancellationToken): ValueTask<T>;
+    skip(): void;
+    skipAsync(cancellationToken?: CancellationToken): Task;
+    startRow(): int;
+    startRowAsync(cancellationToken?: CancellationToken): ValueTask<System_Internal.Int32>;
+}
+
+
+export const NpgsqlBinaryExporter: {
+    new(): NpgsqlBinaryExporter;
+};
+
+
+export type NpgsqlBinaryExporter = NpgsqlBinaryExporter$instance;
+
+export interface NpgsqlBinaryImporter$instance {
+    timeout: TimeSpan;
+    close(): void;
+    closeAsync(cancellationToken?: CancellationToken): ValueTask;
+    complete(): ulong;
+    completeAsync(cancellationToken?: CancellationToken): ValueTask<System_Internal.UInt64>;
+    dispose(): void;
+    disposeAsync(): ValueTask;
+    startRow(): void;
+    startRowAsync(cancellationToken?: CancellationToken): Task;
+    write<T>(value: T): void;
+    write<T>(value: T, npgsqlDbType: NpgsqlDbType): void;
+    write<T>(value: T, dataTypeName: string): void;
+    writeAsync<T>(value: T, cancellationToken?: CancellationToken): Task;
+    writeAsync<T>(value: T, npgsqlDbType: NpgsqlDbType, cancellationToken?: CancellationToken): Task;
+    writeAsync<T>(value: T, dataTypeName: string, cancellationToken?: CancellationToken): Task;
+    writeNull(): void;
+    writeNullAsync(cancellationToken?: CancellationToken): Task;
+    writeRow(...values: unknown[]): void;
+    writeRowAsync(cancellationToken?: CancellationToken, ...values: unknown[]): Task;
+}
+
+
+export const NpgsqlBinaryImporter: {
+    new(): NpgsqlBinaryImporter;
+};
+
+
+export type NpgsqlBinaryImporter = NpgsqlBinaryImporter$instance;
+
+export interface NpgsqlCommand$instance extends DbCommand {
+    allResultTypesAreUnknown: boolean;
+    commandText: string;
+    commandTimeout: int;
+    commandType: CommandType;
+    get connection(): NpgsqlConnection | undefined;
+    set connection(value: NpgsqlConnection);
+    designTimeVisible: boolean;
+    readonly isPrepared: boolean;
+    readonly parameters: NpgsqlParameterCollection;
+    readonly statements: IReadOnlyList<NpgsqlBatchCommand>;
+    get transaction(): NpgsqlTransaction | undefined;
+    set transaction(value: NpgsqlTransaction);
+    get unknownResultTypeList(): boolean[] | undefined;
+    set unknownResultTypeList(value: boolean[]);
+    updatedRowSource: UpdateRowSource;
+    cancel(): void;
+    clone(): NpgsqlCommand;
+    createParameter(): NpgsqlParameter;
+    executeNonQuery(): int;
+    executeNonQueryAsync(cancellationToken: CancellationToken): Task<System_Internal.Int32>;
+    executeReader(behavior?: CommandBehavior): NpgsqlDataReader;
+    executeReaderAsync(cancellationToken?: CancellationToken): Task<NpgsqlDataReader>;
+    executeReaderAsync(behavior: CommandBehavior, cancellationToken?: CancellationToken): Task<NpgsqlDataReader>;
+    executeScalar(): unknown | undefined;
+    executeScalarAsync(cancellationToken: CancellationToken): Task<unknown | undefined>;
+    prepare(): void;
+    prepareAsync(cancellationToken?: CancellationToken): Task;
+    unprepare(): void;
+    unprepareAsync(cancellationToken?: CancellationToken): Task;
+}
+
+
+export const NpgsqlCommand: {
+    new(): NpgsqlCommand;
+    new(cmdText: string): NpgsqlCommand;
+    new(cmdText: string, connection: NpgsqlConnection): NpgsqlCommand;
+    new(cmdText: string, connection: NpgsqlConnection, transaction: NpgsqlTransaction): NpgsqlCommand;
+};
+
+
+export type NpgsqlCommand = NpgsqlCommand$instance;
+
+export interface NpgsqlCommandBuilder$instance extends DbCommandBuilder {
+    quotePrefix: string;
+    quoteSuffix: string;
+    getDeleteCommand(): NpgsqlCommand;
+    getDeleteCommand(useColumnsForParameterNames: boolean): NpgsqlCommand;
+    getInsertCommand(): NpgsqlCommand;
+    getInsertCommand(useColumnsForParameterNames: boolean): NpgsqlCommand;
+    getUpdateCommand(): NpgsqlCommand;
+    getUpdateCommand(useColumnsForParameterNames: boolean): NpgsqlCommand;
+    quoteIdentifier(unquotedIdentifier: string): string;
+    unquoteIdentifier(quotedIdentifier: string): string;
+}
+
+
+export const NpgsqlCommandBuilder: {
+    new(): NpgsqlCommandBuilder;
+    new(adapter: NpgsqlDataAdapter): NpgsqlCommandBuilder;
+    deriveParameters(command: NpgsqlCommand): void;
+};
+
+
+export type NpgsqlCommandBuilder = NpgsqlCommandBuilder$instance;
+
+export interface NpgsqlConnection$instance extends DbConnection {
+    readonly canCreateBatch: boolean;
+    readonly commandTimeout: int;
+    connectionString: string;
+    readonly connectionTimeout: int;
+    readonly database: string;
+    readonly dataSource: string;
+    readonly fullState: ConnectionState;
+    readonly hasIntegerDateTimes: boolean;
+    readonly host: string | undefined;
+    readonly port: int;
+    readonly postgresParameters: IReadOnlyDictionary<System_Internal.String, System_Internal.String>;
+    readonly postgreSqlVersion: Version;
+    readonly processID: int;
+    get provideClientCertificatesCallback(): ProvideClientCertificatesCallback | undefined;
+    set provideClientCertificatesCallback(value: ProvideClientCertificatesCallback);
+    get providePasswordCallback(): ProvidePasswordCallback | undefined;
+    set providePasswordCallback(value: ProvidePasswordCallback);
+    readonly serverVersion: string;
+    get sslClientAuthenticationOptionsCallback(): Action<SslClientAuthenticationOptions> | undefined;
+    set sslClientAuthenticationOptionsCallback(value: Action<SslClientAuthenticationOptions>);
+    readonly state: ConnectionState;
+    readonly timezone: string;
+    readonly typeMapper: INpgsqlTypeMapper;
+    get userCertificateValidationCallback(): RemoteCertificateValidationCallback | undefined;
+    set userCertificateValidationCallback(value: RemoteCertificateValidationCallback);
+    readonly userName: string | undefined;
+    beginBinaryExport(copyToCommand: string): NpgsqlBinaryExporter;
+    beginBinaryExportAsync(copyToCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlBinaryExporter>;
+    beginBinaryImport(copyFromCommand: string): NpgsqlBinaryImporter;
+    beginBinaryImportAsync(copyFromCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlBinaryImporter>;
+    beginRawBinaryCopy(copyCommand: string): NpgsqlRawCopyStream;
+    beginRawBinaryCopyAsync(copyCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlRawCopyStream>;
+    beginTextExport(copyToCommand: string): NpgsqlCopyTextReader;
+    beginTextExportAsync(copyToCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlCopyTextReader>;
+    beginTextImport(copyFromCommand: string): NpgsqlCopyTextWriter;
+    beginTextImportAsync(copyFromCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlCopyTextWriter>;
+    beginTransaction(): NpgsqlTransaction;
+    beginTransaction(level: IsolationLevel): NpgsqlTransaction;
+    beginTransactionAsync(cancellationToken?: CancellationToken): ValueTask<NpgsqlTransaction>;
+    beginTransactionAsync(level: IsolationLevel, cancellationToken?: CancellationToken): ValueTask<NpgsqlTransaction>;
+    changeDatabase(dbName: string): void;
+    cloneWith(connectionString: string): NpgsqlConnection;
+    cloneWithAsync(connectionString: string, cancellationToken?: CancellationToken): ValueTask<NpgsqlConnection>;
+    close(): void;
+    closeAsync(): Task;
+    createBatch(): NpgsqlBatch;
+    createCommand(): NpgsqlCommand;
+    disposeAsync(): ValueTask;
+    enlistTransaction(transaction: Transaction): void;
+    getSchema(): DataTable;
+    getSchema(collectionName: string): DataTable;
+    getSchema(collectionName: string, restrictions: string[]): DataTable;
+    getSchemaAsync(cancellationToken?: CancellationToken): Task<DataTable>;
+    getSchemaAsync(collectionName: string, cancellationToken?: CancellationToken): Task<DataTable>;
+    getSchemaAsync(collectionName: string, restrictions: string[], cancellationToken?: CancellationToken): Task<DataTable>;
+    open(): void;
+    openAsync(cancellationToken: CancellationToken): Task;
+    reloadTypes(): void;
+    reloadTypesAsync(cancellationToken?: CancellationToken): Task;
+    unprepareAll(): void;
+    wait(timeout: int): boolean;
+    wait(timeout: TimeSpan): boolean;
+    wait(): void;
+    waitAsync(timeout: int, cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    waitAsync(timeout: TimeSpan, cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    waitAsync(cancellationToken?: CancellationToken): Task;
+}
+
+
+export const NpgsqlConnection: {
+    new(): NpgsqlConnection;
+    new(connectionString: string): NpgsqlConnection;
+    readonly defaultPort: int;
+    readonly globalTypeMapper: INpgsqlTypeMapper;
+    clearAllPools(): void;
+    clearPool(connection: NpgsqlConnection): void;
+};
+
+
+export type NpgsqlConnection = NpgsqlConnection$instance;
+
+export interface NpgsqlConnectionStringBuilder$instance extends DbConnectionStringBuilder {
+    get applicationName(): string | undefined;
+    set applicationName(value: string);
+    arrayNullabilityMode: ArrayNullabilityMode;
+    autoPrepareMinUsages: int;
+    cancellationTimeout: int;
+    channelBinding: ChannelBinding;
+    checkCertificateRevocation: boolean;
+    get clientEncoding(): string | undefined;
+    set clientEncoding(value: string);
+    commandTimeout: int;
+    connectionIdleLifetime: int;
+    connectionLifetime: int;
+    connectionPruningInterval: int;
+    get database(): string | undefined;
+    set database(value: string);
+    encoding: string;
+    enlist: boolean;
+    gssEncryptionMode: GssEncryptionMode;
+    get host(): string | undefined;
+    set host(value: string);
+    hostRecheckSeconds: int;
+    includeErrorDetail: boolean;
+    includeFailedBatchedCommand: boolean;
+    includeRealm: boolean;
+    internalCommandTimeout: int;
+    item: unknown;
+    keepAlive: int;
+    kerberosServiceName: string;
+    readonly keys: ICollection__System_Collections_Generic<System_Internal.String>;
+    loadBalanceHosts: boolean;
+    loadTableComposites: boolean;
+    logParameters: boolean;
+    maxAutoPrepare: int;
+    maxPoolSize: int;
+    minPoolSize: int;
+    multiplexing: boolean;
+    noResetOnClose: boolean;
+    get options(): string | undefined;
+    set options(value: string);
+    get passfile(): string | undefined;
+    set passfile(value: string);
+    get password(): string | undefined;
+    set password(value: string);
+    persistSecurityInfo: boolean;
+    pooling: boolean;
+    port: int;
+    readBufferSize: int;
+    get requireAuth(): string | undefined;
+    set requireAuth(value: string);
+    get rootCertificate(): string | undefined;
+    set rootCertificate(value: string);
+    get searchPath(): string | undefined;
+    set searchPath(value: string);
+    serverCompatibilityMode: ServerCompatibilityMode;
+    socketReceiveBufferSize: int;
+    socketSendBufferSize: int;
+    get sslCertificate(): string | undefined;
+    set sslCertificate(value: string);
+    get sslKey(): string | undefined;
+    set sslKey(value: string);
+    sslMode: SslMode;
+    sslNegotiation: SslNegotiation;
+    get sslPassword(): string | undefined;
+    set sslPassword(value: string);
+    get targetSessionAttributes(): string | undefined;
+    set targetSessionAttributes(value: string);
+    tcpKeepAlive: boolean;
+    tcpKeepAliveInterval: int;
+    tcpKeepAliveTime: int;
+    timeout: int;
+    get timezone(): string | undefined;
+    set timezone(value: string);
+    trustServerCertificate: boolean;
+    get username(): string | undefined;
+    set username(value: string);
+    readonly values: ICollection__System_Collections_Generic<unknown | undefined>;
+    writeBufferSize: int;
+    writeCoalescingBufferThresholdBytes: int;
+    add(item: KeyValuePair<System_Internal.String, unknown>): void;
+    clear(): void;
+    contains(item: KeyValuePair<System_Internal.String, unknown>): boolean;
+    containsKey(keyword: string): boolean;
+    copyTo(array: KeyValuePair<System_Internal.String, unknown>[], arrayIndex: int): void;
+    equals(obj: unknown): boolean;
+    getEnumerator(): IEnumerator__System_Collections_Generic<KeyValuePair<System_Internal.String, unknown>>;
+    getHashCode(): int;
+    remove(keyword: string): boolean;
+    remove(item: KeyValuePair<System_Internal.String, unknown>): boolean;
+    tryGetValue(keyword: string, value: unknown): boolean;
+}
+
+
+export const NpgsqlConnectionStringBuilder: {
+    new(): NpgsqlConnectionStringBuilder;
+    new(useOdbcRules: boolean): NpgsqlConnectionStringBuilder;
+    new(connectionString: string): NpgsqlConnectionStringBuilder;
+};
+
+
+export type NpgsqlConnectionStringBuilder = NpgsqlConnectionStringBuilder$instance;
+
+export interface NpgsqlCopyTextReader$instance extends StreamReader {
+    timeout: int;
+    cancel(): void;
+    cancelAsync(): Task;
+    disposeAsync(): ValueTask;
+}
+
+
+export const NpgsqlCopyTextReader: {
+    new(): NpgsqlCopyTextReader;
+};
+
+
+export type NpgsqlCopyTextReader = NpgsqlCopyTextReader$instance;
+
+export interface NpgsqlCopyTextWriter$instance extends StreamWriter {
+    timeout: int;
+    cancel(): void;
+    cancelAsync(): Task;
+}
+
+
+export const NpgsqlCopyTextWriter: {
+    new(): NpgsqlCopyTextWriter;
+};
+
+
+export type NpgsqlCopyTextWriter = NpgsqlCopyTextWriter$instance;
+
+export interface NpgsqlDataAdapter$instance extends DbDataAdapter {
+    get deleteCommand(): NpgsqlCommand | undefined;
+    set deleteCommand(value: NpgsqlCommand);
+    get insertCommand(): NpgsqlCommand | undefined;
+    set insertCommand(value: NpgsqlCommand);
+    get selectCommand(): NpgsqlCommand | undefined;
+    set selectCommand(value: NpgsqlCommand);
+    get updateCommand(): NpgsqlCommand | undefined;
+    set updateCommand(value: NpgsqlCommand);
+}
+
+
+export const NpgsqlDataAdapter: {
+    new(): NpgsqlDataAdapter;
+    new(selectCommand: NpgsqlCommand): NpgsqlDataAdapter;
+    new(selectCommandText: string, selectConnection: NpgsqlConnection): NpgsqlDataAdapter;
+    new(selectCommandText: string, selectConnectionString: string): NpgsqlDataAdapter;
+};
+
+
+export type NpgsqlDataAdapter = NpgsqlDataAdapter$instance;
+
+export interface NpgsqlDataReader$instance extends DbDataReader {
+    readonly depth: int;
+    readonly fieldCount: int;
+    readonly hasRows: boolean;
+    readonly isClosed: boolean;
+    readonly isOnRow: boolean;
+    readonly recordsAffected: int;
+    readonly rows: ulong;
+    readonly statements: IReadOnlyList<NpgsqlBatchCommand>;
+    close(): void;
+    closeAsync(): Task;
+    disposeAsync(): ValueTask;
+    get_Item(ordinal: int): unknown;
+    get_Item(name: string): unknown;
+    getBoolean(ordinal: int): boolean;
+    getByte(ordinal: int): byte;
+    getBytes(ordinal: int, dataOffset: long, buffer: byte[], bufferOffset: int, length: int): long;
+    getChar(ordinal: int): char;
+    getChars(ordinal: int, dataOffset: long, buffer: char[], bufferOffset: int, length: int): long;
+    getColumnSchema(): ReadOnlyCollection<NpgsqlDbColumn>;
+    getColumnSchemaAsync(cancellationToken?: CancellationToken): Task<ReadOnlyCollection<DbColumn>>;
+    getData(ordinal: int): NpgsqlNestedDataReader;
+    getDataTypeName(ordinal: int): string;
+    getDataTypeOID(ordinal: int): uint;
+    getDateTime(ordinal: int): DateTime;
+    getDecimal(ordinal: int): decimal;
+    getDouble(ordinal: int): double;
+    getEnumerator(): IEnumerator;
+    getFieldType(ordinal: int): Type;
+    getFieldValue<T>(ordinal: int): T;
+    getFieldValueAsync<T>(ordinal: int, cancellationToken: CancellationToken): Task<T>;
+    getFloat(ordinal: int): float;
+    getGuid(ordinal: int): Guid;
+    getInt16(ordinal: int): short;
+    getInt32(ordinal: int): int;
+    getInt64(ordinal: int): long;
+    getName(ordinal: int): string;
+    getOrdinal(name: string): int;
+    getPostgresType(ordinal: int): PostgresType;
+    getSchemaTable(): DataTable | undefined;
+    getSchemaTableAsync(cancellationToken?: CancellationToken): Task<DataTable | undefined>;
+    getStream(ordinal: int): Stream;
+    getStreamAsync(ordinal: int, cancellationToken?: CancellationToken): Task<Stream>;
+    getString(ordinal: int): string;
+    getTextReader(ordinal: int): TextReader;
+    getTextReaderAsync(ordinal: int, cancellationToken?: CancellationToken): Task<TextReader>;
+    getTimeSpan(ordinal: int): TimeSpan;
+    getValue(ordinal: int): unknown;
+    getValues(values: unknown[]): int;
+    isDBNull(ordinal: int): boolean;
+    isDBNullAsync(ordinal: int, cancellationToken: CancellationToken): Task<System_Internal.Boolean>;
+    nextResult(): boolean;
+    nextResultAsync(cancellationToken: CancellationToken): Task<System_Internal.Boolean>;
+    read(): boolean;
+    readAsync(cancellationToken: CancellationToken): Task<System_Internal.Boolean>;
+}
+
+
+export const NpgsqlDataReader: {
+    new(): NpgsqlDataReader;
+};
+
+
+export type NpgsqlDataReader = NpgsqlDataReader$instance;
+
+export interface NpgsqlDataSource$instance extends DbDataSource {
+    readonly connectionString: string;
+    password: string;
+    clear(): void;
+    createBatch(): NpgsqlBatch;
+    createCommand(commandText?: string): NpgsqlCommand;
+    createConnection(): NpgsqlConnection;
+    openConnection(): NpgsqlConnection;
+    openConnectionAsync(cancellationToken?: CancellationToken): ValueTask<NpgsqlConnection>;
+    reloadTypes(): void;
+    reloadTypesAsync(cancellationToken?: CancellationToken): Task;
+}
+
+
+export const NpgsqlDataSource: {
+    create(connectionStringBuilder: NpgsqlConnectionStringBuilder): NpgsqlDataSource;
+    create(connectionString: string): NpgsqlDataSource;
+};
+
+
+export type NpgsqlDataSource = NpgsqlDataSource$instance;
+
+export interface NpgsqlDataSourceBuilder$instance {
+    readonly connectionString: string;
+    readonly connectionStringBuilder: NpgsqlConnectionStringBuilder;
+    defaultNameTranslator: INpgsqlNameTranslator;
+    name: string;
+    addTypeInfoResolverFactory(factory: PgTypeInfoResolverFactory): void;
+    build(): NpgsqlDataSource;
+    buildMultiHost(): NpgsqlMultiHostDataSource;
+    configureJsonOptions(serializerOptions: JsonSerializerOptions): NpgsqlDataSourceBuilder;
+    configureTracing(configureAction: Action<NpgsqlTracingOptionsBuilder>): NpgsqlDataSourceBuilder;
+    configureTypeLoading(configureAction: Action<NpgsqlTypeLoadingOptionsBuilder>): NpgsqlDataSourceBuilder;
+    enableDynamicJson(jsonbClrTypes?: Type[], jsonClrTypes?: Type[]): NpgsqlDataSourceBuilder;
+    enableParameterLogging(parameterLoggingEnabled?: boolean): NpgsqlDataSourceBuilder;
+    enableRecordsAsTuples(): NpgsqlDataSourceBuilder;
+    enableUnmappedTypes(): NpgsqlDataSourceBuilder;
+    mapComposite<T>(pgName?: string, nameTranslator?: INpgsqlNameTranslator): NpgsqlDataSourceBuilder;
+    mapComposite(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): NpgsqlDataSourceBuilder;
+    mapEnum<TEnum extends number>(pgName?: string, nameTranslator?: INpgsqlNameTranslator): NpgsqlDataSourceBuilder;
+    mapEnum(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): NpgsqlDataSourceBuilder;
+    unmapComposite<T>(pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
+    unmapComposite(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
+    unmapEnum<TEnum extends number>(pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
+    unmapEnum(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
+    useClientCertificate(clientCertificate: X509Certificate): NpgsqlDataSourceBuilder;
+    useClientCertificates(clientCertificates: X509CertificateCollection): NpgsqlDataSourceBuilder;
+    useClientCertificatesCallback(clientCertificatesCallback: Action<X509CertificateCollection>): NpgsqlDataSourceBuilder;
+    useLoggerFactory(loggerFactory: ILoggerFactory): NpgsqlDataSourceBuilder;
+    useNegotiateOptionsCallback(negotiateOptionsCallback: Action<NegotiateAuthenticationClientOptions>): NpgsqlDataSourceBuilder;
+    usePasswordProvider(passwordProvider: Func<NpgsqlConnectionStringBuilder, System_Internal.String>, passwordProviderAsync: Func<NpgsqlConnectionStringBuilder, CancellationToken, ValueTask<System_Internal.String>>): NpgsqlDataSourceBuilder;
+    usePeriodicPasswordProvider(passwordProvider: Func<NpgsqlConnectionStringBuilder, CancellationToken, ValueTask<System_Internal.String>>, successRefreshInterval: TimeSpan, failureRefreshInterval: TimeSpan): NpgsqlDataSourceBuilder;
+    usePhysicalConnectionInitializer(connectionInitializer: Action<NpgsqlConnection>, connectionInitializerAsync: Func<NpgsqlConnection, Task>): NpgsqlDataSourceBuilder;
+    useRootCertificate(rootCertificate: X509Certificate2): NpgsqlDataSourceBuilder;
+    useRootCertificateCallback(rootCertificateCallback: Func<X509Certificate2>): NpgsqlDataSourceBuilder;
+    useRootCertificates(rootCertificates: X509Certificate2Collection): NpgsqlDataSourceBuilder;
+    useRootCertificatesCallback(rootCertificateCallback: Func<X509Certificate2Collection>): NpgsqlDataSourceBuilder;
+    useSslClientAuthenticationOptionsCallback(sslClientAuthenticationOptionsCallback: Action<SslClientAuthenticationOptions>): NpgsqlDataSourceBuilder;
+    useUserCertificateValidationCallback(userCertificateValidationCallback: RemoteCertificateValidationCallback): NpgsqlDataSourceBuilder;
+}
+
+
+export const NpgsqlDataSourceBuilder: {
+    new(connectionString: string): NpgsqlDataSourceBuilder;
+};
+
+
+export interface __NpgsqlDataSourceBuilder$views {
+    As_INpgsqlTypeMapper(): Npgsql_TypeMapping_Internal.INpgsqlTypeMapper$instance;
+}
+
+export type NpgsqlDataSourceBuilder = NpgsqlDataSourceBuilder$instance & __NpgsqlDataSourceBuilder$views;
+
+
+export interface NpgsqlException$instance extends DbException {
+    get batchCommand(): NpgsqlBatchCommand | undefined;
+    set batchCommand(value: NpgsqlBatchCommand);
+    readonly isTransient: boolean;
+}
+
+
+export const NpgsqlException: {
+    new(): NpgsqlException;
+    new(message: string, innerException: Exception): NpgsqlException;
+    new(message: string): NpgsqlException;
+};
+
+
+export type NpgsqlException = NpgsqlException$instance;
+
+export interface NpgsqlFactory$instance extends DbProviderFactory {
+    readonly canCreateBatch: boolean;
+    readonly canCreateCommandBuilder: boolean;
+    readonly canCreateDataAdapter: boolean;
+    createBatch(): DbBatch;
+    createBatchCommand(): DbBatchCommand;
+    createCommand(): DbCommand;
+    createCommandBuilder(): DbCommandBuilder;
+    createConnection(): DbConnection;
+    createConnectionStringBuilder(): DbConnectionStringBuilder;
+    createDataAdapter(): DbDataAdapter;
+    createDataSource(connectionString: string): DbDataSource;
+    createParameter(): DbParameter;
+    getService(serviceType: Type): unknown | undefined;
+}
+
+
+export const NpgsqlFactory: {
+    new(): NpgsqlFactory;
+    readonly instance: NpgsqlFactory;
+};
+
+
+export type NpgsqlFactory = NpgsqlFactory$instance;
+
+export interface NpgsqlLargeObjectManager$instance {
+    readonly has64BitSupport: boolean;
+    maxTransferBlockSize: int;
+    create(preferredOid?: uint): uint;
+    createAsync(preferredOid: uint, cancellationToken?: CancellationToken): Task<System_Internal.UInt32>;
+    exportRemote(oid: uint, path: string): void;
+    exportRemoteAsync(oid: uint, path: string, cancellationToken?: CancellationToken): Task;
+    importRemote(path: string, oid?: uint): void;
+    importRemoteAsync(path: string, oid: uint, cancellationToken?: CancellationToken): Task;
+    openRead(oid: uint): NpgsqlLargeObjectStream;
+    openReadAsync(oid: uint, cancellationToken?: CancellationToken): Task<NpgsqlLargeObjectStream>;
+    openReadWrite(oid: uint): NpgsqlLargeObjectStream;
+    openReadWriteAsync(oid: uint, cancellationToken?: CancellationToken): Task<NpgsqlLargeObjectStream>;
+    unlink(oid: uint): void;
+    unlinkAsync(oid: uint, cancellationToken?: CancellationToken): Task;
+}
+
+
+export const NpgsqlLargeObjectManager: {
+    new(connection: NpgsqlConnection): NpgsqlLargeObjectManager;
+};
+
+
+export type NpgsqlLargeObjectManager = NpgsqlLargeObjectManager$instance;
+
+export interface NpgsqlLargeObjectStream$instance extends Stream {
+    readonly canRead: boolean;
+    readonly canSeek: boolean;
+    readonly canTimeout: boolean;
+    readonly canWrite: boolean;
+    readonly has64BitSupport: boolean;
+    readonly length: long;
+    position: long;
+    close(): void;
+    flush(): void;
+    getLengthAsync(cancellationToken?: CancellationToken): Task<System_Internal.Int64>;
+    read(buffer: byte[], offset: int, count: int): int;
+    readAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task<System_Internal.Int32>;
+    seek(offset: long, origin: SeekOrigin): long;
+    seekAsync(offset: long, origin: SeekOrigin, cancellationToken?: CancellationToken): Task<System_Internal.Int64>;
+    setLength(value: long): void;
+    setLength(value: long, cancellationToken: CancellationToken): Task;
+    write(buffer: byte[], offset: int, count: int): void;
+    writeAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task;
+}
+
+
+export const NpgsqlLargeObjectStream: {
+    new(): NpgsqlLargeObjectStream;
+};
+
+
+export type NpgsqlLargeObjectStream = NpgsqlLargeObjectStream$instance;
+
+export interface NpgsqlLoggingConfiguration$instance {
+}
+
+
+export const NpgsqlLoggingConfiguration: {
+    new(): NpgsqlLoggingConfiguration;
+    initializeLogging(loggerFactory: ILoggerFactory, parameterLoggingEnabled?: boolean): void;
+};
+
+
+export type NpgsqlLoggingConfiguration = NpgsqlLoggingConfiguration$instance;
+
+export interface NpgsqlMetricsOptions$instance {
+}
+
+
+export const NpgsqlMetricsOptions: {
+    new(): NpgsqlMetricsOptions;
+};
+
+
+export type NpgsqlMetricsOptions = NpgsqlMetricsOptions$instance;
+
+export interface NpgsqlMultiHostDataSource$instance extends NpgsqlDataSource {
+    clear(): void;
+    clearDatabaseStates(): void;
+    createConnection(targetSessionAttributes: TargetSessionAttributes): NpgsqlConnection;
+    createConnection(): NpgsqlConnection;
+    openConnection(targetSessionAttributes: TargetSessionAttributes): NpgsqlConnection;
+    openConnection(): NpgsqlConnection;
+    openConnectionAsync(targetSessionAttributes: TargetSessionAttributes, cancellationToken?: CancellationToken): ValueTask<NpgsqlConnection>;
+    openConnectionAsync(cancellationToken?: CancellationToken): ValueTask<NpgsqlConnection>;
+    withTargetSession(targetSessionAttributes: TargetSessionAttributes): NpgsqlDataSource;
+}
+
+
+export const NpgsqlMultiHostDataSource: {
+    new(): NpgsqlMultiHostDataSource;
+};
+
+
+export type NpgsqlMultiHostDataSource = NpgsqlMultiHostDataSource$instance;
+
+export interface NpgsqlNestedDataReader$instance extends DbDataReader {
+    readonly depth: int;
+    readonly fieldCount: int;
+    readonly hasRows: boolean;
+    readonly isClosed: boolean;
+    readonly recordsAffected: int;
+    close(): void;
+    get_Item(ordinal: int): unknown;
+    get_Item(name: string): unknown;
+    getBoolean(ordinal: int): boolean;
+    getByte(ordinal: int): byte;
+    getBytes(ordinal: int, dataOffset: long, buffer: byte[], bufferOffset: int, length: int): long;
+    getChar(ordinal: int): char;
+    getChars(ordinal: int, dataOffset: long, buffer: char[], bufferOffset: int, length: int): long;
+    getData(ordinal: int): NpgsqlNestedDataReader;
+    getDataTypeName(ordinal: int): string;
+    getDateTime(ordinal: int): DateTime;
+    getDecimal(ordinal: int): decimal;
+    getDouble(ordinal: int): double;
+    getEnumerator(): IEnumerator;
+    getFieldType(ordinal: int): Type;
+    getFieldValue<T>(ordinal: int): T;
+    getFloat(ordinal: int): float;
+    getGuid(ordinal: int): Guid;
+    getInt16(ordinal: int): short;
+    getInt32(ordinal: int): int;
+    getInt64(ordinal: int): long;
+    getName(ordinal: int): string;
+    getOrdinal(name: string): int;
+    getString(ordinal: int): string;
+    getValue(ordinal: int): unknown;
+    getValues(values: unknown[]): int;
+    isDBNull(ordinal: int): boolean;
+    nextResult(): boolean;
+    read(): boolean;
+}
+
+
+export const NpgsqlNestedDataReader: {
+    new(): NpgsqlNestedDataReader;
+};
+
+
+export type NpgsqlNestedDataReader = NpgsqlNestedDataReader$instance;
+
+export interface NpgsqlNoticeEventArgs$instance extends EventArgs {
+    readonly notice: PostgresNotice;
+}
+
+
+export const NpgsqlNoticeEventArgs: {
+    new(): NpgsqlNoticeEventArgs;
+};
+
+
+export type NpgsqlNoticeEventArgs = NpgsqlNoticeEventArgs$instance;
+
+export interface NpgsqlNotificationEventArgs$instance extends EventArgs {
+    readonly channel: string;
+    readonly payload: string;
+    readonly PID: int;
+}
+
+
+export const NpgsqlNotificationEventArgs: {
+    new(): NpgsqlNotificationEventArgs;
+};
+
+
+export type NpgsqlNotificationEventArgs = NpgsqlNotificationEventArgs$instance;
+
+export interface NpgsqlOperationInProgressException$instance extends NpgsqlException {
+    readonly commandInProgress: NpgsqlCommand | undefined;
+}
+
+
+export const NpgsqlOperationInProgressException: {
+    new(command: NpgsqlCommand): NpgsqlOperationInProgressException;
+};
+
+
+export type NpgsqlOperationInProgressException = NpgsqlOperationInProgressException$instance;
+
+export interface NpgsqlParameter$instance extends DbParameter {
+    get collection(): NpgsqlParameterCollection | undefined;
+    set collection(value: NpgsqlParameterCollection);
+    get dataTypeName(): string | undefined;
+    set dataTypeName(value: string);
+    dbType: DbType;
+    direction: ParameterDirection;
+    isNullable: boolean;
+    npgsqlDbType: NpgsqlDbType;
+    get npgsqlValue(): unknown | undefined;
+    set npgsqlValue(value: unknown);
+    parameterName: string;
+    readonly postgresType: PostgresType | undefined;
+    precision: byte;
+    scale: byte;
+    size: int;
+    sourceColumn: string;
+    sourceColumnNullMapping: boolean;
+    sourceVersion: DataRowVersion;
+    get value(): unknown | undefined;
+    set value(value: unknown);
+    clone(): NpgsqlParameter;
+    resetDbType(): void;
+}
+
+
+export const NpgsqlParameter: {
+    new(): NpgsqlParameter;
+    new(parameterName: string, value: unknown): NpgsqlParameter;
+    new(parameterName: string, parameterType: NpgsqlDbType): NpgsqlParameter;
+    new(parameterName: string, parameterType: DbType): NpgsqlParameter;
+    new(parameterName: string, parameterType: NpgsqlDbType, size: int): NpgsqlParameter;
+    new(parameterName: string, parameterType: DbType, size: int): NpgsqlParameter;
+    new(parameterName: string, parameterType: NpgsqlDbType, size: int, sourceColumn: string): NpgsqlParameter;
+    new(parameterName: string, parameterType: DbType, size: int, sourceColumn: string): NpgsqlParameter;
+    new(parameterName: string, parameterType: NpgsqlDbType, size: int, sourceColumn: string, direction: ParameterDirection, isNullable: boolean, precision: byte, scale: byte, sourceVersion: DataRowVersion, value: unknown): NpgsqlParameter;
+    new(parameterName: string, parameterType: DbType, size: int, sourceColumn: string, direction: ParameterDirection, isNullable: boolean, precision: byte, scale: byte, sourceVersion: DataRowVersion, value: unknown): NpgsqlParameter;
+};
+
+
+export type NpgsqlParameter = NpgsqlParameter$instance;
+
+export interface NpgsqlParameter_1$instance<T> extends NpgsqlParameter {
+    typedValue: T | undefined;
+    get value(): unknown | undefined;
+    set value(value: unknown);
+}
+
+
+export const NpgsqlParameter_1: {
+    new<T>(): NpgsqlParameter_1<T>;
+    new<T>(parameterName: string, value: T): NpgsqlParameter_1<T>;
+    new<T>(parameterName: string, npgsqlDbType: NpgsqlDbType): NpgsqlParameter_1<T>;
+    new<T>(parameterName: string, dbType: DbType): NpgsqlParameter_1<T>;
+};
+
+
+export type NpgsqlParameter_1<T> = NpgsqlParameter_1$instance<T>;
+
+export interface NpgsqlParameterCollection$instance extends DbParameterCollection {
+    readonly count: int;
+    readonly isFixedSize: boolean;
+    readonly isReadOnly: boolean;
+    readonly isSynchronized: boolean;
+    readonly syncRoot: unknown;
+    add(value: NpgsqlParameter): NpgsqlParameter;
+    add(parameterName: string, parameterType: NpgsqlDbType): NpgsqlParameter;
+    add(parameterName: string, parameterType: NpgsqlDbType, size: int): NpgsqlParameter;
+    add(parameterName: string, parameterType: NpgsqlDbType, size: int, sourceColumn: string): NpgsqlParameter;
+    add(value: unknown): int;
+    addRange(values: ClrArray): void;
+    addWithValue(parameterName: string, value: unknown): NpgsqlParameter;
+    addWithValue(parameterName: string, parameterType: NpgsqlDbType, value: unknown): NpgsqlParameter;
+    addWithValue(parameterName: string, parameterType: NpgsqlDbType, size: int, value: unknown): NpgsqlParameter;
+    addWithValue(parameterName: string, parameterType: NpgsqlDbType, size: int, sourceColumn: string, value: unknown): NpgsqlParameter;
+    addWithValue(value: unknown): NpgsqlParameter;
+    addWithValue(parameterType: NpgsqlDbType, value: unknown): NpgsqlParameter;
+    clear(): void;
+    contains(parameterName: string): boolean;
+    contains(value: unknown): boolean;
+    contains(item: NpgsqlParameter): boolean;
+    copyTo(array: ClrArray, index: int): void;
+    copyTo(array: NpgsqlParameter[], arrayIndex: int): void;
+    get_Item(parameterName: string): NpgsqlParameter;
+    get_Item(index: int): NpgsqlParameter;
+    getEnumerator(): IEnumerator;
+    indexOf(parameterName: string): int;
+    indexOf(value: unknown): int;
+    indexOf(item: NpgsqlParameter): int;
+    insert(index: int, value: unknown): void;
+    insert(index: int, item: NpgsqlParameter): void;
+    remove(parameterName: string): void;
+    remove(value: unknown): void;
+    remove(item: NpgsqlParameter): boolean;
+    removeAt(parameterName: string): void;
+    removeAt(index: int): void;
+    set_Item(parameterName: string, value: NpgsqlParameter): void;
+    set_Item(index: int, value: NpgsqlParameter): void;
+    toArray(): NpgsqlParameter[];
+    tryGetValue(parameterName: string, parameter: NpgsqlParameter): boolean;
+}
+
+
+export const NpgsqlParameterCollection: {
+    new(): NpgsqlParameterCollection;
+};
+
+
+export type NpgsqlParameterCollection = NpgsqlParameterCollection$instance;
+
+export interface NpgsqlRawCopyStream$instance extends Stream {
+    readonly canRead: boolean;
+    readonly canSeek: boolean;
+    readonly canTimeout: boolean;
+    readonly canWrite: boolean;
+    readonly length: long;
+    position: long;
+    readTimeout: int;
+    writeTimeout: int;
+    cancel(): void;
+    cancelAsync(): Task;
+    disposeAsync(): ValueTask;
+    flush(): void;
+    flushAsync(cancellationToken: CancellationToken): Task;
+    read(buffer: byte[], offset: int, count: int): int;
+    read(span: Span<System_Internal.Byte>): int;
+    readAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task<System_Internal.Int32>;
+    readAsync(buffer: Memory<System_Internal.Byte>, cancellationToken: CancellationToken): ValueTask<System_Internal.Int32>;
+    seek(offset: long, origin: SeekOrigin): long;
+    setLength(value: long): void;
+    write(buffer: byte[], offset: int, count: int): void;
+    write(buffer: ReadOnlySpan<System_Internal.Byte>): void;
+    writeAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task;
+    writeAsync(buffer: ReadOnlyMemory<System_Internal.Byte>, cancellationToken?: CancellationToken): ValueTask;
+}
+
+
+export const NpgsqlRawCopyStream: {
+    new(): NpgsqlRawCopyStream;
+};
+
+
+export type NpgsqlRawCopyStream = NpgsqlRawCopyStream$instance;
+
+export interface NpgsqlRowUpdatedEventArgs$instance extends RowUpdatedEventArgs {
+}
+
+
+export const NpgsqlRowUpdatedEventArgs: {
+    new(dataRow: DataRow, command: IDbCommand, statementType: StatementType_Data, tableMapping: DataTableMapping): NpgsqlRowUpdatedEventArgs;
+};
+
+
+export type NpgsqlRowUpdatedEventArgs = NpgsqlRowUpdatedEventArgs$instance;
+
+export interface NpgsqlRowUpdatingEventArgs$instance extends RowUpdatingEventArgs {
+}
+
+
+export const NpgsqlRowUpdatingEventArgs: {
+    new(dataRow: DataRow, command: IDbCommand, statementType: StatementType_Data, tableMapping: DataTableMapping): NpgsqlRowUpdatingEventArgs;
+};
+
+
+export type NpgsqlRowUpdatingEventArgs = NpgsqlRowUpdatingEventArgs$instance;
+
+export interface NpgsqlSlimDataSourceBuilder$instance {
+    readonly connectionString: string;
+    readonly connectionStringBuilder: NpgsqlConnectionStringBuilder;
+    defaultNameTranslator: INpgsqlNameTranslator;
+    name: string;
+    addTypeInfoResolverFactory(factory: PgTypeInfoResolverFactory): void;
+    build(): NpgsqlDataSource;
+    buildMultiHost(): NpgsqlMultiHostDataSource;
+    configureJsonOptions(serializerOptions: JsonSerializerOptions): NpgsqlSlimDataSourceBuilder;
+    configureTracing(configureAction: Action<NpgsqlTracingOptionsBuilder>): NpgsqlSlimDataSourceBuilder;
+    configureTypeLoading(configureAction: Action<NpgsqlTypeLoadingOptionsBuilder>): NpgsqlSlimDataSourceBuilder;
+    enableArrays(): NpgsqlSlimDataSourceBuilder;
+    enableCube(): NpgsqlSlimDataSourceBuilder;
+    enableDynamicJson(jsonbClrTypes?: Type[], jsonClrTypes?: Type[]): NpgsqlSlimDataSourceBuilder;
+    enableExtraConversions(): NpgsqlSlimDataSourceBuilder;
+    enableFullTextSearch(): NpgsqlSlimDataSourceBuilder;
+    enableGeometricTypes(): NpgsqlSlimDataSourceBuilder;
+    enableIntegratedSecurity(): NpgsqlSlimDataSourceBuilder;
+    enableJsonTypes(): NpgsqlSlimDataSourceBuilder;
+    enableLTree(): NpgsqlSlimDataSourceBuilder;
+    enableMultiranges(): NpgsqlSlimDataSourceBuilder;
+    enableNetworkTypes(): NpgsqlSlimDataSourceBuilder;
+    enableParameterLogging(parameterLoggingEnabled?: boolean): NpgsqlSlimDataSourceBuilder;
+    enableRanges(): NpgsqlSlimDataSourceBuilder;
+    enableRecords(): NpgsqlSlimDataSourceBuilder;
+    enableRecordsAsTuples(): NpgsqlSlimDataSourceBuilder;
+    enableTransportSecurity(): NpgsqlSlimDataSourceBuilder;
+    enableUnmappedTypes(): NpgsqlSlimDataSourceBuilder;
+    mapComposite<T>(pgName?: string, nameTranslator?: INpgsqlNameTranslator): NpgsqlSlimDataSourceBuilder;
+    mapComposite(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): NpgsqlSlimDataSourceBuilder;
+    mapEnum<TEnum extends number>(pgName?: string, nameTranslator?: INpgsqlNameTranslator): NpgsqlSlimDataSourceBuilder;
+    mapEnum(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): NpgsqlSlimDataSourceBuilder;
+    unmapComposite<T>(pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
+    unmapComposite(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
+    unmapEnum<TEnum extends number>(pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
+    unmapEnum(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
+    useClientCertificate(clientCertificate: X509Certificate): NpgsqlSlimDataSourceBuilder;
+    useClientCertificates(clientCertificates: X509CertificateCollection): NpgsqlSlimDataSourceBuilder;
+    useClientCertificatesCallback(clientCertificatesCallback: Action<X509CertificateCollection>): NpgsqlSlimDataSourceBuilder;
+    useLoggerFactory(loggerFactory: ILoggerFactory): NpgsqlSlimDataSourceBuilder;
+    useNegotiateOptionsCallback(negotiateOptionsCallback: Action<NegotiateAuthenticationClientOptions>): NpgsqlSlimDataSourceBuilder;
+    usePasswordProvider(passwordProvider: Func<NpgsqlConnectionStringBuilder, System_Internal.String>, passwordProviderAsync: Func<NpgsqlConnectionStringBuilder, CancellationToken, ValueTask<System_Internal.String>>): NpgsqlSlimDataSourceBuilder;
+    usePeriodicPasswordProvider(passwordProvider: Func<NpgsqlConnectionStringBuilder, CancellationToken, ValueTask<System_Internal.String>>, successRefreshInterval: TimeSpan, failureRefreshInterval: TimeSpan): NpgsqlSlimDataSourceBuilder;
+    usePhysicalConnectionInitializer(connectionInitializer: Action<NpgsqlConnection>, connectionInitializerAsync: Func<NpgsqlConnection, Task>): NpgsqlSlimDataSourceBuilder;
+    useRootCertificate(rootCertificate: X509Certificate2): NpgsqlSlimDataSourceBuilder;
+    useRootCertificateCallback(rootCertificateCallback: Func<X509Certificate2>): NpgsqlSlimDataSourceBuilder;
+    useRootCertificates(rootCertificates: X509Certificate2Collection): NpgsqlSlimDataSourceBuilder;
+    useRootCertificatesCallback(rootCertificateCallback: Func<X509Certificate2Collection>): NpgsqlSlimDataSourceBuilder;
+    useSslClientAuthenticationOptionsCallback(sslClientAuthenticationOptionsCallback: Action<SslClientAuthenticationOptions>): NpgsqlSlimDataSourceBuilder;
+    useUserCertificateValidationCallback(userCertificateValidationCallback: RemoteCertificateValidationCallback): NpgsqlSlimDataSourceBuilder;
+}
+
+
+export const NpgsqlSlimDataSourceBuilder: {
+    new(connectionString: string): NpgsqlSlimDataSourceBuilder;
+};
+
+
+export interface __NpgsqlSlimDataSourceBuilder$views {
+    As_INpgsqlTypeMapper(): Npgsql_TypeMapping_Internal.INpgsqlTypeMapper$instance;
+}
+
+export type NpgsqlSlimDataSourceBuilder = NpgsqlSlimDataSourceBuilder$instance & __NpgsqlSlimDataSourceBuilder$views;
+
+
+export interface NpgsqlTracingOptionsBuilder$instance {
+    configureBatchEnrichmentCallback(batchEnrichmentCallback: Action<Activity, NpgsqlBatch>): NpgsqlTracingOptionsBuilder;
+    configureBatchFilter(batchFilter: Func<NpgsqlBatch, System_Internal.Boolean>): NpgsqlTracingOptionsBuilder;
+    configureBatchSpanNameProvider(batchSpanNameProvider: Func<NpgsqlBatch, System_Internal.String>): NpgsqlTracingOptionsBuilder;
+    configureCommandEnrichmentCallback(commandEnrichmentCallback: Action<Activity, NpgsqlCommand>): NpgsqlTracingOptionsBuilder;
+    configureCommandFilter(commandFilter: Func<NpgsqlCommand, System_Internal.Boolean>): NpgsqlTracingOptionsBuilder;
+    configureCommandSpanNameProvider(commandSpanNameProvider: Func<NpgsqlCommand, System_Internal.String>): NpgsqlTracingOptionsBuilder;
+    configureCopyOperationEnrichmentCallback(copyOperationEnrichmentCallback: Action<Activity, System_Internal.String>): NpgsqlTracingOptionsBuilder;
+    configureCopyOperationFilter(copyOperationFilter: Func<System_Internal.String, System_Internal.Boolean>): NpgsqlTracingOptionsBuilder;
+    configureCopyOperationSpanNameProvider(copyOperationSpanNameProvider: Func<System_Internal.String, System_Internal.String>): NpgsqlTracingOptionsBuilder;
+    enableFirstResponseEvent(enable?: boolean): NpgsqlTracingOptionsBuilder;
+    enablePhysicalOpenTracing(enable?: boolean): NpgsqlTracingOptionsBuilder;
+}
+
+
+export const NpgsqlTracingOptionsBuilder: {
+    new(): NpgsqlTracingOptionsBuilder;
+};
+
+
+export type NpgsqlTracingOptionsBuilder = NpgsqlTracingOptionsBuilder$instance;
+
+export interface NpgsqlTransaction$instance extends DbTransaction {
+    readonly connection: NpgsqlConnection | undefined;
+    readonly isolationLevel: IsolationLevel;
+    readonly supportsSavepoints: boolean;
+    commit(): void;
+    commitAsync(cancellationToken?: CancellationToken): Task;
+    disposeAsync(): ValueTask;
+    release(name: string): void;
+    releaseAsync(name: string, cancellationToken?: CancellationToken): Task;
+    rollback(): void;
+    rollback(name: string): void;
+    rollbackAsync(cancellationToken?: CancellationToken): Task;
+    rollbackAsync(name: string, cancellationToken?: CancellationToken): Task;
+    save(name: string): void;
+    saveAsync(name: string, cancellationToken?: CancellationToken): Task;
+}
+
+
+export const NpgsqlTransaction: {
+    new(): NpgsqlTransaction;
+};
+
+
+export type NpgsqlTransaction = NpgsqlTransaction$instance;
+
+export interface NpgsqlTypeLoadingOptionsBuilder$instance {
+    enableTableCompositesLoading(enable?: boolean): NpgsqlTypeLoadingOptionsBuilder;
+    enableTypeLoading(enable?: boolean): NpgsqlTypeLoadingOptionsBuilder;
+    setTypeLoadingSchemas(schemas: IEnumerable__System_Collections_Generic<System_Internal.String>): NpgsqlTypeLoadingOptionsBuilder;
+}
+
+
+export const NpgsqlTypeLoadingOptionsBuilder: {
+    new(): NpgsqlTypeLoadingOptionsBuilder;
+};
+
+
+export type NpgsqlTypeLoadingOptionsBuilder = NpgsqlTypeLoadingOptionsBuilder$instance;
+
+export interface PostgresException$instance extends NpgsqlException {
+    readonly columnName: string | undefined;
+    readonly constraintName: string | undefined;
+    readonly dataTypeName: string | undefined;
+    readonly detail: string | undefined;
+    readonly file: string | undefined;
+    readonly hint: string | undefined;
+    readonly internalPosition: int;
+    readonly internalQuery: string | undefined;
+    readonly invariantSeverity: string;
+    readonly isTransient: boolean;
+    readonly line: string | undefined;
+    readonly messageText: string;
+    readonly position: int;
+    readonly routine: string | undefined;
+    readonly schemaName: string | undefined;
+    readonly severity: string;
+    readonly sqlState: string;
+    readonly tableName: string | undefined;
+    readonly where: string | undefined;
+    getObjectData(info: SerializationInfo, context: StreamingContext): void;
+    toString(): string;
+}
+
+
+export const PostgresException: {
+    new(messageText: string, severity: string, invariantSeverity: string, sqlState: string): PostgresException;
+    new(messageText: string, severity: string, invariantSeverity: string, sqlState: string, detail: string, hint: string, position: int, internalPosition: int, internalQuery: string, where: string, schemaName: string, tableName: string, columnName: string, dataTypeName: string, constraintName: string, file: string, line: string, routine: string): PostgresException;
+};
+
+
+export type PostgresException = PostgresException$instance;
+
+export interface PostgresNotice$instance {
+    get columnName(): string | undefined;
+    set columnName(value: string);
+    get constraintName(): string | undefined;
+    set constraintName(value: string);
+    get dataTypeName(): string | undefined;
+    set dataTypeName(value: string);
+    get detail(): string | undefined;
+    set detail(value: string);
+    get file(): string | undefined;
+    set file(value: string);
+    get hint(): string | undefined;
+    set hint(value: string);
+    internalPosition: int;
+    get internalQuery(): string | undefined;
+    set internalQuery(value: string);
+    readonly invariantSeverity: string;
+    get line(): string | undefined;
+    set line(value: string);
+    messageText: string;
+    position: int;
+    get routine(): string | undefined;
+    set routine(value: string);
+    get schemaName(): string | undefined;
+    set schemaName(value: string);
+    severity: string;
+    sqlState: string;
+    get tableName(): string | undefined;
+    set tableName(value: string);
+    get where(): string | undefined;
+    set where(value: string);
+}
+
+
+export const PostgresNotice: {
+    new(severity: string, invariantSeverity: string, sqlState: string, messageText: string): PostgresNotice;
+    new(messageText: string, severity: string, invariantSeverity: string, sqlState: string, detail: string, hint: string, position: int, internalPosition: int, internalQuery: string, where: string, schemaName: string, tableName: string, columnName: string, dataTypeName: string, constraintName: string, file: string, line: string, routine: string): PostgresNotice;
+};
+
+
+export type PostgresNotice = PostgresNotice$instance;
+
+export abstract class NpgsqlEventId$instance {
+    static readonly openingConnection: int;
+    static readonly openedConnection: int;
+    static readonly closingConnection: int;
+    static readonly closedConnection: int;
+    static readonly openingPhysicalConnection: int;
+    static readonly openedPhysicalConnection: int;
+    static readonly closingPhysicalConnection: int;
+    static readonly closedPhysicalConnection: int;
+    static readonly startingWait: int;
+    static readonly receivedNotice: int;
+    static readonly connectionExceededMaximumLifetime: int;
+    static readonly sendingKeepalive: int;
+    static readonly completedKeepalive: int;
+    static readonly keepaliveFailed: int;
+    static readonly breakingConnection: int;
+    static readonly caughtUserExceptionInNoticeEventHandler: int;
+    static readonly caughtUserExceptionInNotificationEventHandler: int;
+    static readonly exceptionWhenClosingPhysicalConnection: int;
+    static readonly exceptionWhenOpeningConnectionForMultiplexing: int;
+    static readonly executingCommand: int;
+    static readonly commandExecutionCompleted: int;
+    static readonly cancellingCommand: int;
+    static readonly executingInternalCommand: int;
+    static readonly preparingCommandExplicitly: int;
+    static readonly commandPreparedExplicitly: int;
+    static readonly autoPreparingStatement: int;
+    static readonly unpreparingCommand: int;
+    static readonly derivingParameters: int;
+    static readonly exceptionWhenWritingMultiplexedCommands: int;
+    static readonly startedTransaction: int;
+    static readonly committedTransaction: int;
+    static readonly rolledBackTransaction: int;
+    static readonly creatingSavepoint: int;
+    static readonly rolledBackToSavepoint: int;
+    static readonly releasedSavepoint: int;
+    static readonly exceptionDuringTransactionDispose: int;
+    static readonly enlistedVolatileResourceManager: int;
+    static readonly committingSinglePhaseTransaction: int;
+    static readonly rollingBackSinglePhaseTransaction: int;
+    static readonly singlePhaseTransactionRollbackFailed: int;
+    static readonly preparingTwoPhaseTransaction: int;
+    static readonly committingTwoPhaseTransaction: int;
+    static readonly twoPhaseTransactionCommitFailed: int;
+    static readonly rollingBackTwoPhaseTransaction: int;
+    static readonly twoPhaseTransactionRollbackFailed: int;
+    static readonly twoPhaseTransactionInDoubt: int;
+    static readonly connectionInUseWhenRollingBack: int;
+    static readonly cleaningUpResourceManager: int;
+    static readonly startingBinaryExport: int;
+    static readonly startingBinaryImport: int;
+    static readonly startingTextExport: int;
+    static readonly startingTextImport: int;
+    static readonly startingRawCopy: int;
+    static readonly copyOperationCompleted: int;
+    static readonly copyOperationCancelled: int;
+    static readonly exceptionWhenDisposingCopyOperation: int;
+    static readonly creatingReplicationSlot: int;
+    static readonly droppingReplicationSlot: int;
+    static readonly startingLogicalReplication: int;
+    static readonly startingPhysicalReplication: int;
+    static readonly executingReplicationCommand: int;
+    static readonly receivedReplicationPrimaryKeepalive: int;
+    static readonly sendingReplicationStandbyStatusUpdate: int;
+    static readonly sentReplicationFeedbackMessage: int;
+    static readonly replicationFeedbackMessageSendingFailed: int;
+}
+
+
+export type NpgsqlEventId = NpgsqlEventId$instance;
+
+export abstract class PostgresErrorCodes$instance {
+    static readonly successfulCompletion: string;
+    static readonly warning: string;
+    static readonly dynamicResultSetsReturnedWarning: string;
+    static readonly implicitZeroBitPaddingWarning: string;
+    static readonly nullValueEliminatedInSetFunctionWarning: string;
+    static readonly privilegeNotGrantedWarning: string;
+    static readonly privilegeNotRevokedWarning: string;
+    static readonly stringDataRightTruncationWarning: string;
+    static readonly deprecatedFeatureWarning: string;
+    static readonly noData: string;
+    static readonly noAdditionalDynamicResultSetsReturned: string;
+    static readonly sqlStatementNotYetComplete: string;
+    static readonly connectionException: string;
+    static readonly connectionDoesNotExist: string;
+    static readonly connectionFailure: string;
+    static readonly sqlClientUnableToEstablishSqlConnection: string;
+    static readonly sqlServerRejectedEstablishmentOfSqlConnection: string;
+    static readonly transactionResolutionUnknown: string;
+    static readonly protocolViolation: string;
+    static readonly triggeredActionException: string;
+    static readonly featureNotSupported: string;
+    static readonly invalidTransactionInitiation: string;
+    static readonly locatorException: string;
+    static readonly invalidLocatorSpecification: string;
+    static readonly invalidGrantor: string;
+    static readonly invalidGrantOperation: string;
+    static readonly invalidRoleSpecification: string;
+    static readonly diagnosticsException: string;
+    static readonly stackedDiagnosticsAccessedWithoutActiveHandler: string;
+    static readonly caseNotFound: string;
+    static readonly cardinalityViolation: string;
+    static readonly dataException: string;
+    static readonly arraySubscriptError: string;
+    static readonly characterNotInRepertoire: string;
+    static readonly datetimeFieldOverflow: string;
+    static readonly divisionByZero: string;
+    static readonly errorInAssignment: string;
+    static readonly escapeCharacterConflict: string;
+    static readonly indicatorOverflow: string;
+    static readonly intervalFieldOverflow: string;
+    static readonly invalidArgumentForLogarithm: string;
+    static readonly invalidArgumentForNtileFunction: string;
+    static readonly invalidArgumentForNthValueFunction: string;
+    static readonly invalidArgumentForPowerFunction: string;
+    static readonly invalidArgumentForWidthBucketFunction: string;
+    static readonly invalidCharacterValueForCast: string;
+    static readonly invalidDatetimeFormat: string;
+    static readonly invalidEscapeCharacter: string;
+    static readonly invalidEscapeOctet: string;
+    static readonly invalidEscapeSequence: string;
+    static readonly nonstandardUseOfEscapeCharacter: string;
+    static readonly invalidIndicatorParameterValue: string;
+    static readonly invalidParameterValue: string;
+    static readonly invalidRegularExpression: string;
+    static readonly invalidRowCountInLimitClause: string;
+    static readonly invalidRowCountInResultOffsetClause: string;
+    static readonly invalidTablesampleArgument: string;
+    static readonly invalidTablesampleRepeat: string;
+    static readonly invalidTimeZoneDisplacementValue: string;
+    static readonly invalidUseOfEscapeCharacter: string;
+    static readonly mostSpecificTypeMismatch: string;
+    static readonly nullValueNotAllowed: string;
+    static readonly nullValueNoIndicatorParameter: string;
+    static readonly numericValueOutOfRange: string;
+    static readonly stringDataLengthMismatch: string;
+    static readonly stringDataRightTruncation: string;
+    static readonly substringError: string;
+    static readonly trimError: string;
+    static readonly unterminatedCString: string;
+    static readonly zeroLengthCharacterString: string;
+    static readonly floatingPointException: string;
+    static readonly invalidTextRepresentation: string;
+    static readonly invalidBinaryRepresentation: string;
+    static readonly badCopyFileFormat: string;
+    static readonly untranslatableCharacter: string;
+    static readonly notAnXmlDocument: string;
+    static readonly invalidXmlDocument: string;
+    static readonly invalidXmlContent: string;
+    static readonly invalidXmlComment: string;
+    static readonly invalidXmlProcessingInstruction: string;
+    static readonly integrityConstraintViolation: string;
+    static readonly restrictViolation: string;
+    static readonly notNullViolation: string;
+    static readonly foreignKeyViolation: string;
+    static readonly uniqueViolation: string;
+    static readonly checkViolation: string;
+    static readonly exclusionViolation: string;
+    static readonly invalidCursorState: string;
+    static readonly invalidTransactionState: string;
+    static readonly activeSqlTransaction: string;
+    static readonly branchTransactionAlreadyActive: string;
+    static readonly heldCursorRequiresSameIsolationLevel: string;
+    static readonly inappropriateAccessModeForBranchTransaction: string;
+    static readonly inappropriateIsolationLevelForBranchTransaction: string;
+    static readonly noActiveSqlTransactionForBranchTransaction: string;
+    static readonly readOnlySqlTransaction: string;
+    static readonly schemaAndDataStatementMixingNotSupported: string;
+    static readonly noActiveSqlTransaction: string;
+    static readonly inFailedSqlTransaction: string;
+    static readonly invalidSqlStatementName: string;
+    static readonly triggeredDataChangeViolation: string;
+    static readonly invalidAuthorizationSpecification: string;
+    static readonly invalidPassword: string;
+    static readonly dependentPrivilegeDescriptorsStillExist: string;
+    static readonly dependentObjectsStillExist: string;
+    static readonly invalidTransactionTermination: string;
+    static readonly sqlRoutineException: string;
+    static readonly functionExecutedNoReturnStatementSqlRoutineException: string;
+    static readonly modifyingSqlDataNotPermittedSqlRoutineException: string;
+    static readonly prohibitedSqlStatementAttemptedSqlRoutineException: string;
+    static readonly readingSqlDataNotPermittedSqlRoutineException: string;
+    static readonly invalidCursorName: string;
+    static readonly externalRoutineException: string;
+    static readonly containingSqlNotPermittedExternalRoutineException: string;
+    static readonly modifyingSqlDataNotPermittedExternalRoutineException: string;
+    static readonly prohibitedSqlStatementAttemptedExternalRoutineException: string;
+    static readonly readingSqlDataNotPermittedExternalRoutineException: string;
+    static readonly externalRoutineInvocationException: string;
+    static readonly invalidSqlstateReturnedExternalRoutineInvocationException: string;
+    static readonly nullValueNotAllowedExternalRoutineInvocationException: string;
+    static readonly triggerProtocolViolatedExternalRoutineInvocationException: string;
+    static readonly srfProtocolViolatedExternalRoutineInvocationException: string;
+    static readonly eventTriggerProtocolViolatedExternalRoutineInvocationException: string;
+    static readonly savepointException: string;
+    static readonly invalidSavepointSpecification: string;
+    static readonly invalidCatalogName: string;
+    static readonly invalidSchemaName: string;
+    static readonly transactionRollback: string;
+    static readonly transactionIntegrityConstraintViolation: string;
+    static readonly serializationFailure: string;
+    static readonly statementCompletionUnknown: string;
+    static readonly deadlockDetected: string;
+    static readonly syntaxErrorOrAccessRuleViolation: string;
+    static readonly syntaxError: string;
+    static readonly insufficientPrivilege: string;
+    static readonly cannotCoerce: string;
+    static readonly groupingError: string;
+    static readonly windowingError: string;
+    static readonly invalidRecursion: string;
+    static readonly invalidForeignKey: string;
+    static readonly invalidName: string;
+    static readonly nameTooLong: string;
+    static readonly reservedName: string;
+    static readonly datatypeMismatch: string;
+    static readonly indeterminateDatatype: string;
+    static readonly collationMismatch: string;
+    static readonly indeterminateCollation: string;
+    static readonly wrongObjectType: string;
+    static readonly undefinedColumn: string;
+    static readonly undefinedFunction: string;
+    static readonly undefinedTable: string;
+    static readonly undefinedParameter: string;
+    static readonly undefinedObject: string;
+    static readonly duplicateColumn: string;
+    static readonly duplicateCursor: string;
+    static readonly duplicateDatabase: string;
+    static readonly duplicateFunction: string;
+    static readonly duplicatePreparedStatement: string;
+    static readonly duplicateSchema: string;
+    static readonly duplicateTable: string;
+    static readonly duplicateAlias: string;
+    static readonly duplicateObject: string;
+    static readonly ambiguousColumn: string;
+    static readonly ambiguousFunction: string;
+    static readonly ambiguousParameter: string;
+    static readonly ambiguousAlias: string;
+    static readonly invalidColumnReference: string;
+    static readonly invalidColumnDefinition: string;
+    static readonly invalidCursorDefinition: string;
+    static readonly invalidDatabaseDefinition: string;
+    static readonly invalidFunctionDefinition: string;
+    static readonly invalidPreparedStatementDefinition: string;
+    static readonly invalidSchemaDefinition: string;
+    static readonly invalidTableDefinition: string;
+    static readonly invalidObjectDefinition: string;
+    static readonly withCheckOptionViolation: string;
+    static readonly insufficientResources: string;
+    static readonly diskFull: string;
+    static readonly outOfMemory: string;
+    static readonly tooManyConnections: string;
+    static readonly configurationLimitExceeded: string;
+    static readonly programLimitExceeded: string;
+    static readonly statementTooComplex: string;
+    static readonly tooManyColumns: string;
+    static readonly tooManyArguments: string;
+    static readonly objectNotInPrerequisiteState: string;
+    static readonly objectInUse: string;
+    static readonly cantChangeRuntimeParam: string;
+    static readonly lockNotAvailable: string;
+    static readonly operatorIntervention: string;
+    static readonly queryCanceled: string;
+    static readonly adminShutdown: string;
+    static readonly crashShutdown: string;
+    static readonly cannotConnectNow: string;
+    static readonly databaseDropped: string;
+    static readonly idleSessionTimeout: string;
+    static readonly systemError: string;
+    static readonly ioError: string;
+    static readonly undefinedFile: string;
+    static readonly duplicateFile: string;
+    static readonly snapshotFailure: string;
+    static readonly configFileError: string;
+    static readonly lockFileExists: string;
+    static readonly fdwError: string;
+    static readonly fdwColumnNameNotFound: string;
+    static readonly fdwDynamicParameterValueNeeded: string;
+    static readonly fdwFunctionSequenceError: string;
+    static readonly fdwInconsistentDescriptorInformation: string;
+    static readonly fdwInvalidAttributeValue: string;
+    static readonly fdwInvalidColumnName: string;
+    static readonly fdwInvalidColumnNumber: string;
+    static readonly fdwInvalidDataType: string;
+    static readonly fdwInvalidDataTypeDescriptors: string;
+    static readonly fdwInvalidDescriptorFieldIdentifier: string;
+    static readonly fdwInvalidHandle: string;
+    static readonly fdwInvalidOptionIndex: string;
+    static readonly fdwInvalidOptionName: string;
+    static readonly fdwInvalidStringLengthOrBufferLength: string;
+    static readonly fdwInvalidStringFormat: string;
+    static readonly fdwInvalidUseOfNullPointer: string;
+    static readonly fdwTooManyHandles: string;
+    static readonly fdwOutOfMemory: string;
+    static readonly fdwNoSchemas: string;
+    static readonly fdwOptionNameNotFound: string;
+    static readonly fdwReplyHandle: string;
+    static readonly fdwSchemaNotFound: string;
+    static readonly fdwTableNotFound: string;
+    static readonly fdwUnableToCreateExecution: string;
+    static readonly fdwUnableToCreateReply: string;
+    static readonly fdwUnableToEstablishConnection: string;
+    static readonly plpgsqlError: string;
+    static readonly raiseException: string;
+    static readonly noDataFound: string;
+    static readonly tooManyRows: string;
+    static readonly assertFailure: string;
+    static readonly internalError: string;
+    static readonly dataCorrupted: string;
+    static readonly indexCorrupted: string;
+}
+
+
+export type PostgresErrorCodes = PostgresErrorCodes$instance;
+