@tsonic/efcore-npgsql 10.0.2 → 10.0.7

package/Npgsql/internal/index.d.ts

@@ -15,31 +15,31 @@ 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 { Hashtable, 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";
+import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { ICollection_1, IDictionary_2, IEnumerable_1, IEnumerator_1, IList_1, IReadOnlyDictionary_2, IReadOnlyList_1, KeyValuePair_2 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { ReadOnlyCollection_1 } from "@tsonic/dotnet/System.Collections.ObjectModel/internal/index.js";
+import * as System_Collections_Internal from "@tsonic/dotnet/System.Collections/internal/index.js";
+import type { Hashtable, ICollection, IDictionary, IEnumerable, IEnumerator, IList } from "@tsonic/dotnet/System.Collections/internal/index.js";
+import * as System_ComponentModel_Internal from "@tsonic/dotnet/System.ComponentModel/internal/index.js";
+import type { IComponent, ICustomTypeDescriptor } from "@tsonic/dotnet/System.ComponentModel/internal/index.js";
+import * as System_Data_Common_Internal from "@tsonic/dotnet/System.Data.Common/internal/index.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/internal/index.js";
+import * as System_Data_Internal from "@tsonic/dotnet/System.Data/internal/index.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/internal/index.js";
+import type { Activity } from "@tsonic/dotnet/System.Diagnostics/internal/index.js";
+import * as System_IO_Internal from "@tsonic/dotnet/System.IO/internal/index.js";
+import type { SeekOrigin, Stream, StreamReader, StreamWriter, TextReader } from "@tsonic/dotnet/System.IO/internal/index.js";
+import type { NegotiateAuthenticationClientOptions, RemoteCertificateValidationCallback, SslClientAuthenticationOptions } from "@tsonic/dotnet/System.Net.Security/internal/index.js";
+import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
+import type { ISerializable, SerializationInfo, StreamingContext } from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
+import type { X509Certificate, X509Certificate2, X509Certificate2Collection, X509CertificateCollection } from "@tsonic/dotnet/System.Security.Cryptography.X509Certificates/internal/index.js";
+import type { JsonSerializerOptions } from "@tsonic/dotnet/System.Text.Json/internal/index.js";
+import type { Task, Task_1, ValueTask, ValueTask_1 } from "@tsonic/dotnet/System.Threading.Tasks/internal/index.js";
+import type { CancellationToken } from "@tsonic/dotnet/System.Threading/internal/index.js";
+import type { Transaction } from "@tsonic/dotnet/System.Transactions/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Action_1, Action_2, Array as ClrArray, AsyncCallback, Boolean as ClrBoolean, Byte, Char, DateTime, Decimal, Double, Enum, EventArgs, EventHandler, Exception, Func_1, Func_2, Func_3, Guid, IAsyncDisposable, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IFormattable, Int16, Int32, Int64, IntPtr, IServiceProvider, ISpanFormattable, Memory_1, MulticastDelegate, Nullable_1, Object as ClrObject, ReadOnlyMemory_1, ReadOnlySpan_1, Single, Span_1, String as ClrString, TimeSpan, Type, UInt32, UInt64, ValueType, Version, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { ILoggerFactory } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging/internal/index.js";
 
 export enum ArrayNullabilityMode {
     Never = 0,
@@ -131,40 +131,45 @@ export type ProvidePasswordCallback = (host: string, port: int, database: string
 
 
 export interface INpgsqlNameTranslator$instance {
+    readonly __tsonic_iface_Npgsql_INpgsqlNameTranslator: never;
+
     TranslateTypeName(clrName: string): string;
 }
 
 
 export type INpgsqlNameTranslator = INpgsqlNameTranslator$instance;
 
-export abstract class NpgsqlBatch$protected {
-    protected readonly DbBatchCommands: DbBatchCommandCollection;
-    protected DbConnection: DbConnection;
-    protected DbTransaction: DbTransaction | undefined;
-    protected CreateDbBatchCommand(): DbBatchCommand;
-    protected ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
-    protected ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task<DbDataReader>;
-}
+export interface NpgsqlBatch$instance extends DbBatch {
+    readonly __tsonic_type_Npgsql_NpgsqlBatch: never;
 
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlBatch$instance extends NpgsqlBatch$protected, DbBatch {
     readonly BatchCommands: NpgsqlBatchCommandCollection;
     get Connection(): NpgsqlConnection | undefined;
-    set Connection(value: NpgsqlConnection);
+    set Connection(value: NpgsqlConnection | undefined);
+    readonly DbBatchCommands: DbBatchCommandCollection;
+    get DbConnection(): DbConnection | undefined;
+    set DbConnection(value: DbConnection | undefined);
+    get DbTransaction(): DbTransaction | undefined;
+    set DbTransaction(value: DbTransaction | undefined);
     EnableErrorBarriers: boolean;
     Timeout: int;
     get Transaction(): NpgsqlTransaction | undefined;
-    set Transaction(value: NpgsqlTransaction);
+    set Transaction(value: NpgsqlTransaction | undefined);
     Cancel(): void;
     CreateBatchCommand(): NpgsqlBatchCommand;
+    CreateDbBatchCommand(): DbBatchCommand;
     Dispose(): void;
+    ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
+    ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task_1<DbDataReader>;
     ExecuteNonQuery(): int;
-    ExecuteNonQueryAsync(cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
+    ExecuteNonQueryAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
     ExecuteReader(behavior?: CommandBehavior): NpgsqlDataReader;
-    ExecuteReaderAsync(cancellationToken?: CancellationToken): Task<NpgsqlDataReader>;
-    ExecuteReaderAsync(behavior: CommandBehavior, cancellationToken?: CancellationToken): Task<NpgsqlDataReader>;
+    ExecuteReaderAsync(cancellationToken?: CancellationToken): Task_1<NpgsqlDataReader>;
+    ExecuteReaderAsync(behavior: CommandBehavior, cancellationToken?: CancellationToken): Task_1<NpgsqlDataReader>;
     ExecuteScalar(): unknown | undefined;
-    ExecuteScalarAsync(cancellationToken?: CancellationToken): Task<unknown | undefined>;
+    ExecuteScalarAsync(cancellationToken?: CancellationToken): Task_1<unknown | undefined>;
     Prepare(): void;
     PrepareAsync(cancellationToken?: CancellationToken): Task;
 }
@@ -177,16 +182,14 @@ export const NpgsqlBatch: {
 
 export type NpgsqlBatch = NpgsqlBatch$instance;
 
-export abstract class NpgsqlBatchCommand$protected {
-    protected readonly DbParameterCollection: DbParameterCollection;
-}
-
+export interface NpgsqlBatchCommand$instance extends DbBatchCommand {
+    readonly __tsonic_type_Npgsql_NpgsqlBatchCommand: never;
 
-export interface NpgsqlBatchCommand$instance extends NpgsqlBatchCommand$protected, DbBatchCommand {
-    AppendErrorBarrier: Nullable<System_Internal.Boolean>;
+    AppendErrorBarrier: Nullable_1<System_Internal.Boolean>;
     readonly CanCreateParameter: boolean;
     CommandText: string;
     CommandType: CommandType;
+    readonly DbParameterCollection: DbParameterCollection;
     OID: uint;
     readonly Parameters: NpgsqlParameterCollection;
     readonly RecordsAffected: int;
@@ -205,16 +208,17 @@ export const NpgsqlBatchCommand: {
 
 export type NpgsqlBatchCommand = NpgsqlBatchCommand$instance;
 
-export abstract class NpgsqlBatchCommandCollection$protected {
-    protected GetBatchCommand(index: int): DbBatchCommand;
-    protected SetBatchCommand(index: int, batchCommand: DbBatchCommand): void;
-}
+export interface NpgsqlBatchCommandCollection$instance extends DbBatchCommandCollection {
+    readonly __tsonic_type_Npgsql_NpgsqlBatchCommandCollection: never;
 
+    readonly __tsonic_iface_System_Collections_Generic_ICollection_1: never;
+    readonly __tsonic_iface_System_Collections_Generic_IEnumerable_1: never;
+    readonly __tsonic_iface_System_Collections_Generic_IList_1: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
 
-export interface NpgsqlBatchCommandCollection$instance extends NpgsqlBatchCommandCollection$protected, DbBatchCommandCollection {
     readonly Count: int;
     readonly IsReadOnly: boolean;
-    Item: NpgsqlBatchCommand;
+    [index: number]: NpgsqlBatchCommand;
     Add(item: NpgsqlBatchCommand): void;
     Add(item: DbBatchCommand): void;
     Clear(): void;
@@ -222,7 +226,8 @@ export interface NpgsqlBatchCommandCollection$instance extends NpgsqlBatchComman
     Contains(item: DbBatchCommand): boolean;
     CopyTo(array: NpgsqlBatchCommand[], arrayIndex: int): void;
     CopyTo(array: DbBatchCommand[], arrayIndex: int): void;
-    GetEnumerator(): IEnumerator__System_Collections_Generic<DbBatchCommand>;
+    GetBatchCommand(index: int): DbBatchCommand;
+    GetEnumerator(): IEnumerator_1<DbBatchCommand>;
     IndexOf(item: NpgsqlBatchCommand): int;
     IndexOf(item: DbBatchCommand): int;
     Insert(index: int, item: NpgsqlBatchCommand): void;
@@ -230,17 +235,23 @@ export interface NpgsqlBatchCommandCollection$instance extends NpgsqlBatchComman
     Remove(item: NpgsqlBatchCommand): boolean;
     Remove(item: DbBatchCommand): boolean;
     RemoveAt(index: int): void;
+    SetBatchCommand(index: int, batchCommand: DbBatchCommand): void;
 }
 
 
 export const NpgsqlBatchCommandCollection: {
-    new(): NpgsqlBatchCommandCollection;
 };
 
 
 export type NpgsqlBatchCommandCollection = NpgsqlBatchCommandCollection$instance;
 
 export interface NpgsqlBinaryExporter$instance {
+    readonly __tsonic_type_Npgsql_NpgsqlBinaryExporter: never;
+
+    readonly __tsonic_iface_Npgsql_ICancelable: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly IsNull: boolean;
     Timeout: TimeSpan;
     Cancel(): void;
@@ -249,28 +260,33 @@ export interface NpgsqlBinaryExporter$instance {
     DisposeAsync(): ValueTask;
     Read<T>(): T;
     Read<T>(type: NpgsqlDbType): T;
-    ReadAsync<T>(cancellationToken?: CancellationToken): ValueTask<T>;
-    ReadAsync<T>(type: NpgsqlDbType, cancellationToken?: CancellationToken): ValueTask<T>;
+    ReadAsync<T>(cancellationToken?: CancellationToken): ValueTask_1<T>;
+    ReadAsync<T>(type: NpgsqlDbType, cancellationToken?: CancellationToken): ValueTask_1<T>;
     Skip(): void;
     SkipAsync(cancellationToken?: CancellationToken): Task;
     StartRow(): int;
-    StartRowAsync(cancellationToken?: CancellationToken): ValueTask<System_Internal.Int32>;
+    StartRowAsync(cancellationToken?: CancellationToken): ValueTask_1<System_Internal.Int32>;
 }
 
 
 export const NpgsqlBinaryExporter: {
-    new(): NpgsqlBinaryExporter;
 };
 
 
 export type NpgsqlBinaryExporter = NpgsqlBinaryExporter$instance;
 
 export interface NpgsqlBinaryImporter$instance {
+    readonly __tsonic_type_Npgsql_NpgsqlBinaryImporter: never;
+
+    readonly __tsonic_iface_Npgsql_ICancelable: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Timeout: TimeSpan;
     Close(): void;
     CloseAsync(cancellationToken?: CancellationToken): ValueTask;
     Complete(): ulong;
-    CompleteAsync(cancellationToken?: CancellationToken): ValueTask<System_Internal.UInt64>;
+    CompleteAsync(cancellationToken?: CancellationToken): ValueTask_1<System_Internal.UInt64>;
     Dispose(): void;
     DisposeAsync(): ValueTask;
     StartRow(): void;
@@ -289,49 +305,54 @@ export interface NpgsqlBinaryImporter$instance {
 
 
 export const NpgsqlBinaryImporter: {
-    new(): NpgsqlBinaryImporter;
 };
 
 
 export type NpgsqlBinaryImporter = NpgsqlBinaryImporter$instance;
 
-export abstract class NpgsqlCommand$protected {
-    protected DbConnection: DbConnection;
-    protected readonly DbParameterCollection: DbParameterCollection;
-    protected DbTransaction: DbTransaction | undefined;
-    protected CreateDbParameter(): DbParameter;
-    protected Dispose(disposing: boolean): void;
-    protected ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
-    protected ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task<DbDataReader>;
-}
+export interface NpgsqlCommand$instance extends DbCommand {
+    readonly __tsonic_type_Npgsql_NpgsqlCommand: never;
 
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_Data_IDbCommand: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlCommand$instance extends NpgsqlCommand$protected, DbCommand {
     AllResultTypesAreUnknown: boolean;
     CommandText: string;
     CommandTimeout: int;
     CommandType: CommandType;
     get Connection(): NpgsqlConnection | undefined;
-    set Connection(value: NpgsqlConnection);
+    set Connection(value: NpgsqlConnection | undefined);
+    get DbConnection(): DbConnection | undefined;
+    set DbConnection(value: DbConnection | undefined);
+    readonly DbParameterCollection: DbParameterCollection;
+    get DbTransaction(): DbTransaction | undefined;
+    set DbTransaction(value: DbTransaction | undefined);
     DesignTimeVisible: boolean;
     readonly IsPrepared: boolean;
     readonly Parameters: NpgsqlParameterCollection;
-    readonly Statements: IReadOnlyList<NpgsqlBatchCommand>;
+    readonly Statements: IReadOnlyList_1<NpgsqlBatchCommand>;
     get Transaction(): NpgsqlTransaction | undefined;
-    set Transaction(value: NpgsqlTransaction);
+    set Transaction(value: NpgsqlTransaction | undefined);
     get UnknownResultTypeList(): boolean[] | undefined;
-    set UnknownResultTypeList(value: boolean[]);
+    set UnknownResultTypeList(value: boolean[] | undefined);
     UpdatedRowSource: UpdateRowSource;
     Cancel(): void;
     Clone(): NpgsqlCommand;
+    CreateDbParameter(): DbParameter;
     CreateParameter(): NpgsqlParameter;
+    Dispose(disposing: boolean): void;
+    ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
+    ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task_1<DbDataReader>;
     ExecuteNonQuery(): int;
-    ExecuteNonQueryAsync(cancellationToken: CancellationToken): Task<System_Internal.Int32>;
+    ExecuteNonQueryAsync(cancellationToken: CancellationToken): Task_1<System_Internal.Int32>;
     ExecuteReader(behavior?: CommandBehavior): NpgsqlDataReader;
-    ExecuteReaderAsync(cancellationToken?: CancellationToken): Task<NpgsqlDataReader>;
-    ExecuteReaderAsync(behavior: CommandBehavior, cancellationToken?: CancellationToken): Task<NpgsqlDataReader>;
+    ExecuteReaderAsync(cancellationToken?: CancellationToken): Task_1<NpgsqlDataReader>;
+    ExecuteReaderAsync(behavior: CommandBehavior, cancellationToken?: CancellationToken): Task_1<NpgsqlDataReader>;
     ExecuteScalar(): unknown | undefined;
-    ExecuteScalarAsync(cancellationToken: CancellationToken): Task<unknown | undefined>;
+    ExecuteScalarAsync(cancellationToken: CancellationToken): Task_1<unknown | undefined>;
     Prepare(): void;
     PrepareAsync(cancellationToken?: CancellationToken): Task;
     Unprepare(): void;
@@ -349,25 +370,26 @@ export const NpgsqlCommand: {
 
 export type NpgsqlCommand = NpgsqlCommand$instance;
 
-export abstract class NpgsqlCommandBuilder$protected {
-    protected ApplyParameterInfo(p: DbParameter, row: DataRow, statementType: StatementType_Data, whereClause: boolean): void;
-    protected GetParameterName(parameterOrdinal: int): string;
-    protected GetParameterName(parameterName: string): string;
-    protected GetParameterPlaceholder(parameterOrdinal: int): string;
-    protected SetRowUpdatingHandler(adapter: DbDataAdapter): void;
-}
+export interface NpgsqlCommandBuilder$instance extends DbCommandBuilder {
+    readonly __tsonic_type_Npgsql_NpgsqlCommandBuilder: never;
 
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlCommandBuilder$instance extends NpgsqlCommandBuilder$protected, DbCommandBuilder {
     QuotePrefix: string;
     QuoteSuffix: string;
+    ApplyParameterInfo(p: DbParameter, row: DataRow, statementType: StatementType_Data, whereClause: boolean): void;
     GetDeleteCommand(): NpgsqlCommand;
     GetDeleteCommand(useColumnsForParameterNames: boolean): NpgsqlCommand;
     GetInsertCommand(): NpgsqlCommand;
     GetInsertCommand(useColumnsForParameterNames: boolean): NpgsqlCommand;
+    GetParameterName(parameterOrdinal: int): string;
+    GetParameterName(parameterName: string): string;
+    GetParameterPlaceholder(parameterOrdinal: int): string;
     GetUpdateCommand(): NpgsqlCommand;
     GetUpdateCommand(useColumnsForParameterNames: boolean): NpgsqlCommand;
     QuoteIdentifier(unquotedIdentifier: string): string;
+    SetRowUpdatingHandler(adapter: DbDataAdapter): void;
     UnquoteIdentifier(quotedIdentifier: string): string;
 }
 
@@ -381,72 +403,76 @@ export const NpgsqlCommandBuilder: {
 
 export type NpgsqlCommandBuilder = NpgsqlCommandBuilder$instance;
 
-export abstract class NpgsqlConnection$protected {
-    protected readonly DbProviderFactory: DbProviderFactory;
-    protected BeginDbTransaction(isolationLevel: IsolationLevel): DbTransaction;
-    protected BeginDbTransactionAsync(isolationLevel: IsolationLevel, cancellationToken: CancellationToken): ValueTask<DbTransaction>;
-    protected CreateDbBatch(): DbBatch;
-    protected CreateDbCommand(): DbCommand;
-    protected Dispose(disposing: boolean): void;
-}
+export interface NpgsqlConnection$instance extends DbConnection {
+    readonly __tsonic_type_Npgsql_NpgsqlConnection: never;
 
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_Data_IDbConnection: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlConnection$instance extends NpgsqlConnection$protected, DbConnection {
     readonly CanCreateBatch: boolean;
     readonly CommandTimeout: int;
     ConnectionString: string;
     readonly ConnectionTimeout: int;
     readonly Database: string;
     readonly DataSource: string;
+    readonly DbProviderFactory: DbProviderFactory;
     FullState: ConnectionState;
     readonly HasIntegerDateTimes: boolean;
     readonly Host: string | undefined;
     readonly Port: int;
-    readonly PostgresParameters: IReadOnlyDictionary<System_Internal.String, System_Internal.String>;
+    readonly PostgresParameters: IReadOnlyDictionary_2<System_Internal.String, System_Internal.String>;
     readonly PostgreSqlVersion: Version;
     readonly ProcessID: int;
     get ProvideClientCertificatesCallback(): ProvideClientCertificatesCallback | undefined;
-    set ProvideClientCertificatesCallback(value: ProvideClientCertificatesCallback);
+    set ProvideClientCertificatesCallback(value: ProvideClientCertificatesCallback | undefined);
     get ProvidePasswordCallback(): ProvidePasswordCallback | undefined;
-    set ProvidePasswordCallback(value: ProvidePasswordCallback);
+    set ProvidePasswordCallback(value: ProvidePasswordCallback | undefined);
     readonly ServerVersion: string;
-    get SslClientAuthenticationOptionsCallback(): Action<SslClientAuthenticationOptions> | undefined;
-    set SslClientAuthenticationOptionsCallback(value: Action<SslClientAuthenticationOptions>);
+    get SslClientAuthenticationOptionsCallback(): Action_1<SslClientAuthenticationOptions> | undefined;
+    set SslClientAuthenticationOptionsCallback(value: Action_1<SslClientAuthenticationOptions> | undefined);
     readonly State: ConnectionState;
     readonly Timezone: string;
     readonly TypeMapper: INpgsqlTypeMapper;
     get UserCertificateValidationCallback(): RemoteCertificateValidationCallback | undefined;
-    set UserCertificateValidationCallback(value: RemoteCertificateValidationCallback);
+    set UserCertificateValidationCallback(value: RemoteCertificateValidationCallback | undefined);
     readonly UserName: string | undefined;
     BeginBinaryExport(copyToCommand: string): NpgsqlBinaryExporter;
-    BeginBinaryExportAsync(copyToCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlBinaryExporter>;
+    BeginBinaryExportAsync(copyToCommand: string, cancellationToken?: CancellationToken): Task_1<NpgsqlBinaryExporter>;
     BeginBinaryImport(copyFromCommand: string): NpgsqlBinaryImporter;
-    BeginBinaryImportAsync(copyFromCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlBinaryImporter>;
+    BeginBinaryImportAsync(copyFromCommand: string, cancellationToken?: CancellationToken): Task_1<NpgsqlBinaryImporter>;
+    BeginDbTransaction(isolationLevel: IsolationLevel): DbTransaction;
+    BeginDbTransactionAsync(isolationLevel: IsolationLevel, cancellationToken: CancellationToken): ValueTask_1<DbTransaction>;
     BeginRawBinaryCopy(copyCommand: string): NpgsqlRawCopyStream;
-    BeginRawBinaryCopyAsync(copyCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlRawCopyStream>;
+    BeginRawBinaryCopyAsync(copyCommand: string, cancellationToken?: CancellationToken): Task_1<NpgsqlRawCopyStream>;
     BeginTextExport(copyToCommand: string): NpgsqlCopyTextReader;
-    BeginTextExportAsync(copyToCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlCopyTextReader>;
+    BeginTextExportAsync(copyToCommand: string, cancellationToken?: CancellationToken): Task_1<NpgsqlCopyTextReader>;
     BeginTextImport(copyFromCommand: string): NpgsqlCopyTextWriter;
-    BeginTextImportAsync(copyFromCommand: string, cancellationToken?: CancellationToken): Task<NpgsqlCopyTextWriter>;
+    BeginTextImportAsync(copyFromCommand: string, cancellationToken?: CancellationToken): Task_1<NpgsqlCopyTextWriter>;
     BeginTransaction(): NpgsqlTransaction;
     BeginTransaction(level: IsolationLevel): NpgsqlTransaction;
-    BeginTransactionAsync(cancellationToken?: CancellationToken): ValueTask<NpgsqlTransaction>;
-    BeginTransactionAsync(level: IsolationLevel, cancellationToken?: CancellationToken): ValueTask<NpgsqlTransaction>;
+    BeginTransactionAsync(cancellationToken?: CancellationToken): ValueTask_1<NpgsqlTransaction>;
+    BeginTransactionAsync(level: IsolationLevel, cancellationToken?: CancellationToken): ValueTask_1<NpgsqlTransaction>;
     ChangeDatabase(dbName: string): void;
     CloneWith(connectionString: string): NpgsqlConnection;
-    CloneWithAsync(connectionString: string, cancellationToken?: CancellationToken): ValueTask<NpgsqlConnection>;
+    CloneWithAsync(connectionString: string, cancellationToken?: CancellationToken): ValueTask_1<NpgsqlConnection>;
     Close(): void;
     CloseAsync(): Task;
     CreateBatch(): NpgsqlBatch;
     CreateCommand(): NpgsqlCommand;
+    CreateDbBatch(): DbBatch;
+    CreateDbCommand(): DbCommand;
+    Dispose(disposing: boolean): void;
     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>;
+    GetSchemaAsync(cancellationToken?: CancellationToken): Task_1<DataTable>;
+    GetSchemaAsync(collectionName: string, cancellationToken?: CancellationToken): Task_1<DataTable>;
+    GetSchemaAsync(collectionName: string, restrictions: string[], cancellationToken?: CancellationToken): Task_1<DataTable>;
     Open(): void;
     OpenAsync(cancellationToken: CancellationToken): Task;
     ReloadTypes(): void;
@@ -455,8 +481,8 @@ export interface NpgsqlConnection$instance extends NpgsqlConnection$protected, D
     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(timeout: int, cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
+    WaitAsync(timeout: TimeSpan, cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     WaitAsync(cancellationToken?: CancellationToken): Task;
 }
 
@@ -473,41 +499,46 @@ export const NpgsqlConnection: {
 
 export type NpgsqlConnection = NpgsqlConnection$instance;
 
-export abstract class NpgsqlConnectionStringBuilder$protected {
-    protected GetProperties(propertyDescriptors: Hashtable): void;
-}
+export interface NpgsqlConnectionStringBuilder$instance extends DbConnectionStringBuilder {
+    readonly __tsonic_type_Npgsql_NpgsqlConnectionStringBuilder: never;
 
+    readonly __tsonic_iface_System_Collections_Generic_ICollection_1: never;
+    readonly __tsonic_iface_System_Collections_Generic_IDictionary_2: never;
+    readonly __tsonic_iface_System_Collections_Generic_IEnumerable_1: never;
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IDictionary: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_ComponentModel_ICustomTypeDescriptor: never;
 
-export interface NpgsqlConnectionStringBuilder$instance extends NpgsqlConnectionStringBuilder$protected, DbConnectionStringBuilder {
     get ApplicationName(): string | undefined;
-    set ApplicationName(value: string);
+    set ApplicationName(value: string | undefined);
     ArrayNullabilityMode: ArrayNullabilityMode;
     AutoPrepareMinUsages: int;
     CancellationTimeout: int;
     ChannelBinding: ChannelBinding;
     CheckCertificateRevocation: boolean;
     get ClientEncoding(): string | undefined;
-    set ClientEncoding(value: string);
+    set ClientEncoding(value: string | undefined);
     CommandTimeout: int;
     ConnectionIdleLifetime: int;
     ConnectionLifetime: int;
     ConnectionPruningInterval: int;
     get Database(): string | undefined;
-    set Database(value: string);
+    set Database(value: string | undefined);
     Encoding: string;
     Enlist: boolean;
     GssEncryptionMode: GssEncryptionMode;
     get Host(): string | undefined;
-    set Host(value: string);
+    set Host(value: string | undefined);
     HostRecheckSeconds: int;
     IncludeErrorDetail: boolean;
     IncludeFailedBatchedCommand: boolean;
     IncludeRealm: boolean;
     InternalCommandTimeout: int;
-    Item: unknown;
+    [keyword: string]: unknown;
     KeepAlive: int;
     KerberosServiceName: string;
-    readonly Keys: ICollection__System_Collections_Generic<System_Internal.String>;
+    readonly Keys: ICollection_1<System_Internal.String>;
     LoadBalanceHosts: boolean;
     LoadTableComposites: boolean;
     LogParameters: boolean;
@@ -517,56 +548,57 @@ export interface NpgsqlConnectionStringBuilder$instance extends NpgsqlConnection
     Multiplexing: boolean;
     NoResetOnClose: boolean;
     get Options(): string | undefined;
-    set Options(value: string);
+    set Options(value: string | undefined);
     get Passfile(): string | undefined;
-    set Passfile(value: string);
+    set Passfile(value: string | undefined);
     get Password(): string | undefined;
-    set Password(value: string);
+    set Password(value: string | undefined);
     PersistSecurityInfo: boolean;
     Pooling: boolean;
     Port: int;
     ReadBufferSize: int;
     get RequireAuth(): string | undefined;
-    set RequireAuth(value: string);
+    set RequireAuth(value: string | undefined);
     get RootCertificate(): string | undefined;
-    set RootCertificate(value: string);
+    set RootCertificate(value: string | undefined);
     get SearchPath(): string | undefined;
-    set SearchPath(value: string);
+    set SearchPath(value: string | undefined);
     ServerCompatibilityMode: ServerCompatibilityMode;
     SocketReceiveBufferSize: int;
     SocketSendBufferSize: int;
     get SslCertificate(): string | undefined;
-    set SslCertificate(value: string);
+    set SslCertificate(value: string | undefined);
     get SslKey(): string | undefined;
-    set SslKey(value: string);
+    set SslKey(value: string | undefined);
     SslMode: SslMode;
     SslNegotiation: SslNegotiation;
     get SslPassword(): string | undefined;
-    set SslPassword(value: string);
+    set SslPassword(value: string | undefined);
     get TargetSessionAttributes(): string | undefined;
-    set TargetSessionAttributes(value: string);
+    set TargetSessionAttributes(value: string | undefined);
     TcpKeepAlive: boolean;
     TcpKeepAliveInterval: int;
     TcpKeepAliveTime: int;
     Timeout: int;
     get Timezone(): string | undefined;
-    set Timezone(value: string);
+    set Timezone(value: string | undefined);
     TrustServerCertificate: boolean;
     get Username(): string | undefined;
-    set Username(value: string);
-    readonly Values: ICollection__System_Collections_Generic<unknown | undefined>;
+    set Username(value: string | undefined);
+    readonly Values: ICollection_1<unknown | undefined>;
     WriteBufferSize: int;
     WriteCoalescingBufferThresholdBytes: int;
-    Add(item: KeyValuePair<System_Internal.String, unknown>): void;
+    Add(item: KeyValuePair_2<System_Internal.String, unknown>): void;
     Clear(): void;
-    Contains(item: KeyValuePair<System_Internal.String, unknown>): boolean;
+    Contains(item: KeyValuePair_2<System_Internal.String, unknown>): boolean;
     ContainsKey(keyword: string): boolean;
-    CopyTo(array: KeyValuePair<System_Internal.String, unknown>[], arrayIndex: int): void;
+    CopyTo(array: KeyValuePair_2<System_Internal.String, unknown>[], arrayIndex: int): void;
     Equals(obj: unknown): boolean;
-    GetEnumerator(): IEnumerator__System_Collections_Generic<KeyValuePair<System_Internal.String, unknown>>;
+    GetEnumerator(): IEnumerator_1<KeyValuePair_2<System_Internal.String, unknown>>;
     GetHashCode(): int;
+    GetProperties(propertyDescriptors: Hashtable): void;
     Remove(keyword: string): boolean;
-    Remove(item: KeyValuePair<System_Internal.String, unknown>): boolean;
+    Remove(item: KeyValuePair_2<System_Internal.String, unknown>): boolean;
     TryGetValue(keyword: string, value: unknown): boolean;
 }
 
@@ -581,6 +613,12 @@ export const NpgsqlConnectionStringBuilder: {
 export type NpgsqlConnectionStringBuilder = NpgsqlConnectionStringBuilder$instance;
 
 export interface NpgsqlCopyTextReader$instance extends StreamReader {
+    readonly __tsonic_type_Npgsql_NpgsqlCopyTextReader: never;
+
+    readonly __tsonic_iface_Npgsql_ICancelable: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Timeout: int;
     Cancel(): void;
     CancelAsync(): Task;
@@ -589,13 +627,18 @@ export interface NpgsqlCopyTextReader$instance extends StreamReader {
 
 
 export const NpgsqlCopyTextReader: {
-    new(): NpgsqlCopyTextReader;
 };
 
 
 export type NpgsqlCopyTextReader = NpgsqlCopyTextReader$instance;
 
 export interface NpgsqlCopyTextWriter$instance extends StreamWriter {
+    readonly __tsonic_type_Npgsql_NpgsqlCopyTextWriter: never;
+
+    readonly __tsonic_iface_Npgsql_ICancelable: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Timeout: int;
     Cancel(): void;
     CancelAsync(): Task;
@@ -603,29 +646,32 @@ export interface NpgsqlCopyTextWriter$instance extends StreamWriter {
 
 
 export const NpgsqlCopyTextWriter: {
-    new(): NpgsqlCopyTextWriter;
 };
 
 
 export type NpgsqlCopyTextWriter = NpgsqlCopyTextWriter$instance;
 
-export abstract class NpgsqlDataAdapter$protected {
-    protected CreateRowUpdatedEvent(dataRow: DataRow, command: IDbCommand, statementType: StatementType_Data, tableMapping: DataTableMapping): RowUpdatedEventArgs;
-    protected CreateRowUpdatingEvent(dataRow: DataRow, command: IDbCommand, statementType: StatementType_Data, tableMapping: DataTableMapping): RowUpdatingEventArgs;
-    protected OnRowUpdated(value: RowUpdatedEventArgs): void;
-    protected OnRowUpdating(value: RowUpdatingEventArgs): void;
-}
+export interface NpgsqlDataAdapter$instance extends DbDataAdapter {
+    readonly __tsonic_type_Npgsql_NpgsqlDataAdapter: never;
 
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_Data_IDataAdapter: never;
+    readonly __tsonic_iface_System_Data_IDbDataAdapter: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlDataAdapter$instance extends NpgsqlDataAdapter$protected, DbDataAdapter {
     get DeleteCommand(): NpgsqlCommand | undefined;
-    set DeleteCommand(value: NpgsqlCommand);
+    set DeleteCommand(value: NpgsqlCommand | undefined);
     get InsertCommand(): NpgsqlCommand | undefined;
-    set InsertCommand(value: NpgsqlCommand);
+    set InsertCommand(value: NpgsqlCommand | undefined);
     get SelectCommand(): NpgsqlCommand | undefined;
-    set SelectCommand(value: NpgsqlCommand);
+    set SelectCommand(value: NpgsqlCommand | undefined);
     get UpdateCommand(): NpgsqlCommand | undefined;
-    set UpdateCommand(value: NpgsqlCommand);
+    set UpdateCommand(value: NpgsqlCommand | undefined);
+    CreateRowUpdatedEvent(dataRow: DataRow, command: IDbCommand, statementType: StatementType_Data, tableMapping: DataTableMapping): RowUpdatedEventArgs;
+    CreateRowUpdatingEvent(dataRow: DataRow, command: IDbCommand, statementType: StatementType_Data, tableMapping: DataTableMapping): RowUpdatingEventArgs;
+    OnRowUpdated(value: RowUpdatedEventArgs): void;
+    OnRowUpdating(value: RowUpdatingEventArgs): void;
 }
 
 
@@ -639,13 +685,16 @@ export const NpgsqlDataAdapter: {
 
 export type NpgsqlDataAdapter = NpgsqlDataAdapter$instance;
 
-export abstract class NpgsqlDataReader$protected {
-    protected Dispose(disposing: boolean): void;
-    protected GetDbDataReader(ordinal: int): DbDataReader;
-}
+export interface NpgsqlDataReader$instance extends DbDataReader {
+    readonly __tsonic_type_Npgsql_NpgsqlDataReader: never;
 
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Data_Common_IDbColumnSchemaGenerator: never;
+    readonly __tsonic_iface_System_Data_IDataReader: never;
+    readonly __tsonic_iface_System_Data_IDataRecord: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlDataReader$instance extends NpgsqlDataReader$protected, DbDataReader {
     readonly Depth: int;
     readonly FieldCount: int;
     readonly HasRows: boolean;
@@ -653,9 +702,10 @@ export interface NpgsqlDataReader$instance extends NpgsqlDataReader$protected, D
     readonly IsOnRow: boolean;
     readonly RecordsAffected: int;
     readonly Rows: ulong;
-    readonly Statements: IReadOnlyList<NpgsqlBatchCommand>;
+    readonly Statements: IReadOnlyList_1<NpgsqlBatchCommand>;
     Close(): void;
     CloseAsync(): Task;
+    Dispose(disposing: boolean): void;
     DisposeAsync(): ValueTask;
     get_Item(ordinal: int): unknown;
     get_Item(name: string): unknown;
@@ -664,18 +714,19 @@ export interface NpgsqlDataReader$instance extends NpgsqlDataReader$protected, D
     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>>;
+    GetColumnSchema(): ReadOnlyCollection_1<NpgsqlDbColumn>;
+    GetColumnSchemaAsync(cancellationToken?: CancellationToken): Task_1<ReadOnlyCollection_1<DbColumn>>;
     GetData(ordinal: int): NpgsqlNestedDataReader;
     GetDataTypeName(ordinal: int): string;
     GetDataTypeOID(ordinal: int): uint;
     GetDateTime(ordinal: int): DateTime;
+    GetDbDataReader(ordinal: int): DbDataReader;
     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>;
+    GetFieldValueAsync<T>(ordinal: int, cancellationToken: CancellationToken): Task_1<T>;
     GetFloat(ordinal: int): float;
     GetGuid(ordinal: int): Guid;
     GetInt16(ordinal: int): short;
@@ -685,53 +736,53 @@ export interface NpgsqlDataReader$instance extends NpgsqlDataReader$protected, D
     GetOrdinal(name: string): int;
     GetPostgresType(ordinal: int): PostgresType;
     GetSchemaTable(): DataTable | undefined;
-    GetSchemaTableAsync(cancellationToken?: CancellationToken): Task<DataTable | undefined>;
+    GetSchemaTableAsync(cancellationToken?: CancellationToken): Task_1<DataTable | undefined>;
     GetStream(ordinal: int): Stream;
-    GetStreamAsync(ordinal: int, cancellationToken?: CancellationToken): Task<Stream>;
+    GetStreamAsync(ordinal: int, cancellationToken?: CancellationToken): Task_1<Stream>;
     GetString(ordinal: int): string;
     GetTextReader(ordinal: int): TextReader;
-    GetTextReaderAsync(ordinal: int, cancellationToken?: CancellationToken): Task<TextReader>;
+    GetTextReaderAsync(ordinal: int, cancellationToken?: CancellationToken): Task_1<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>;
+    IsDBNullAsync(ordinal: int, cancellationToken: CancellationToken): Task_1<System_Internal.Boolean>;
     NextResult(): boolean;
-    NextResultAsync(cancellationToken: CancellationToken): Task<System_Internal.Boolean>;
+    NextResultAsync(cancellationToken: CancellationToken): Task_1<System_Internal.Boolean>;
     Read(): boolean;
-    ReadAsync(cancellationToken: CancellationToken): Task<System_Internal.Boolean>;
+    ReadAsync(cancellationToken: CancellationToken): Task_1<System_Internal.Boolean>;
 }
 
 
 export const NpgsqlDataReader: {
-    new(): NpgsqlDataReader;
 };
 
 
 export type NpgsqlDataReader = NpgsqlDataReader$instance;
 
-export abstract class NpgsqlDataSource$protected {
-    protected CreateDbBatch(): DbBatch;
-    protected CreateDbCommand(commandText?: string): DbCommand;
-    protected CreateDbConnection(): DbConnection;
-    protected Dispose(disposing: boolean): void;
-    protected DisposeAsyncBase(): ValueTask;
-    protected DisposeAsyncCore(): ValueTask;
-    protected DisposeBase(): void;
-    protected OpenDbConnection(): DbConnection;
-    protected OpenDbConnectionAsync(cancellationToken?: CancellationToken): ValueTask<DbConnection>;
-}
+export interface NpgsqlDataSource$instance extends DbDataSource {
+    readonly __tsonic_type_Npgsql_NpgsqlDataSource: never;
 
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlDataSource$instance extends NpgsqlDataSource$protected, DbDataSource {
     readonly ConnectionString: string;
     Password: string;
     Clear(): void;
     CreateBatch(): NpgsqlBatch;
     CreateCommand(commandText?: string): NpgsqlCommand;
     CreateConnection(): NpgsqlConnection;
+    CreateDbBatch(): DbBatch;
+    CreateDbCommand(commandText?: string): DbCommand;
+    CreateDbConnection(): DbConnection;
+    Dispose(disposing: boolean): void;
+    DisposeAsyncBase(): ValueTask;
+    DisposeAsyncCore(): ValueTask;
+    DisposeBase(): void;
     OpenConnection(): NpgsqlConnection;
-    OpenConnectionAsync(cancellationToken?: CancellationToken): ValueTask<NpgsqlConnection>;
+    OpenConnectionAsync(cancellationToken?: CancellationToken): ValueTask_1<NpgsqlConnection>;
+    OpenDbConnection(): DbConnection;
+    OpenDbConnectionAsync(cancellationToken?: CancellationToken): ValueTask_1<DbConnection>;
     ReloadTypes(): void;
     ReloadTypesAsync(cancellationToken?: CancellationToken): Task;
 }
@@ -746,16 +797,21 @@ export const NpgsqlDataSource: {
 export type NpgsqlDataSource = NpgsqlDataSource$instance;
 
 export interface NpgsqlDataSourceBuilder$instance {
+    readonly __tsonic_type_Npgsql_NpgsqlDataSourceBuilder: never;
+
+    readonly __tsonic_iface_Npgsql_TypeMapping_INpgsqlTypeMapper: never;
+
     readonly ConnectionString: string;
     readonly ConnectionStringBuilder: NpgsqlConnectionStringBuilder;
     DefaultNameTranslator: INpgsqlNameTranslator;
-    Name: string;
+    get Name(): string | undefined;
+    set Name(value: string | undefined);
     AddTypeInfoResolverFactory(factory: PgTypeInfoResolverFactory): void;
     Build(): NpgsqlDataSource;
     BuildMultiHost(): NpgsqlMultiHostDataSource;
     ConfigureJsonOptions(serializerOptions: JsonSerializerOptions): NpgsqlDataSourceBuilder;
-    ConfigureTracing(configureAction: Action<NpgsqlTracingOptionsBuilder>): NpgsqlDataSourceBuilder;
-    ConfigureTypeLoading(configureAction: Action<NpgsqlTypeLoadingOptionsBuilder>): NpgsqlDataSourceBuilder;
+    ConfigureTracing(configureAction: Action_1<NpgsqlTracingOptionsBuilder>): NpgsqlDataSourceBuilder;
+    ConfigureTypeLoading(configureAction: Action_1<NpgsqlTypeLoadingOptionsBuilder>): NpgsqlDataSourceBuilder;
     EnableDynamicJson(jsonbClrTypes?: Type[], jsonClrTypes?: Type[]): NpgsqlDataSourceBuilder;
     EnableParameterLogging(parameterLoggingEnabled?: boolean): NpgsqlDataSourceBuilder;
     EnableRecordsAsTuples(): NpgsqlDataSourceBuilder;
@@ -770,17 +826,17 @@ export interface NpgsqlDataSourceBuilder$instance {
     UnmapEnum(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
     UseClientCertificate(clientCertificate: X509Certificate): NpgsqlDataSourceBuilder;
     UseClientCertificates(clientCertificates: X509CertificateCollection): NpgsqlDataSourceBuilder;
-    UseClientCertificatesCallback(clientCertificatesCallback: Action<X509CertificateCollection>): NpgsqlDataSourceBuilder;
+    UseClientCertificatesCallback(clientCertificatesCallback: Action_1<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;
+    UseNegotiateOptionsCallback(negotiateOptionsCallback: Action_1<NegotiateAuthenticationClientOptions>): NpgsqlDataSourceBuilder;
+    UsePasswordProvider(passwordProvider: Func_2<NpgsqlConnectionStringBuilder, System_Internal.String>, passwordProviderAsync: Func_3<NpgsqlConnectionStringBuilder, CancellationToken, ValueTask_1<System_Internal.String>>): NpgsqlDataSourceBuilder;
+    UsePeriodicPasswordProvider(passwordProvider: Func_3<NpgsqlConnectionStringBuilder, CancellationToken, ValueTask_1<System_Internal.String>>, successRefreshInterval: TimeSpan, failureRefreshInterval: TimeSpan): NpgsqlDataSourceBuilder;
+    UsePhysicalConnectionInitializer(connectionInitializer: Action_1<NpgsqlConnection>, connectionInitializerAsync: Func_2<NpgsqlConnection, Task>): NpgsqlDataSourceBuilder;
     UseRootCertificate(rootCertificate: X509Certificate2): NpgsqlDataSourceBuilder;
-    UseRootCertificateCallback(rootCertificateCallback: Func<X509Certificate2>): NpgsqlDataSourceBuilder;
+    UseRootCertificateCallback(rootCertificateCallback: Func_1<X509Certificate2>): NpgsqlDataSourceBuilder;
     UseRootCertificates(rootCertificates: X509Certificate2Collection): NpgsqlDataSourceBuilder;
-    UseRootCertificatesCallback(rootCertificateCallback: Func<X509Certificate2Collection>): NpgsqlDataSourceBuilder;
-    UseSslClientAuthenticationOptionsCallback(sslClientAuthenticationOptionsCallback: Action<SslClientAuthenticationOptions>): NpgsqlDataSourceBuilder;
+    UseRootCertificatesCallback(rootCertificateCallback: Func_1<X509Certificate2Collection>): NpgsqlDataSourceBuilder;
+    UseSslClientAuthenticationOptionsCallback(sslClientAuthenticationOptionsCallback: Action_1<SslClientAuthenticationOptions>): NpgsqlDataSourceBuilder;
     UseUserCertificateValidationCallback(userCertificateValidationCallback: RemoteCertificateValidationCallback): NpgsqlDataSourceBuilder;
 }
 
@@ -797,14 +853,14 @@ export interface __NpgsqlDataSourceBuilder$views {
 export type NpgsqlDataSourceBuilder = NpgsqlDataSourceBuilder$instance & __NpgsqlDataSourceBuilder$views;
 
 
-export abstract class NpgsqlException$protected {
-    protected readonly DbBatchCommand: DbBatchCommand | undefined;
-}
+export interface NpgsqlException$instance extends DbException {
+    readonly __tsonic_type_Npgsql_NpgsqlException: never;
 
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
 
-export interface NpgsqlException$instance extends NpgsqlException$protected, DbException {
     get BatchCommand(): NpgsqlBatchCommand | undefined;
-    set BatchCommand(value: NpgsqlBatchCommand);
+    set BatchCommand(value: NpgsqlBatchCommand | undefined);
+    readonly DbBatchCommand: DbBatchCommand | undefined;
     readonly IsTransient: boolean;
 }
 
@@ -813,13 +869,16 @@ export const NpgsqlException: {
     new(): NpgsqlException;
     new(message: string, innerException: Exception): NpgsqlException;
     new(message: string): NpgsqlException;
-    new(info: SerializationInfo, context: StreamingContext): NpgsqlException;
 };
 
 
 export type NpgsqlException = NpgsqlException$instance;
 
 export interface NpgsqlFactory$instance extends DbProviderFactory {
+    readonly __tsonic_type_Npgsql_NpgsqlFactory: never;
+
+    readonly __tsonic_iface_System_IServiceProvider: never;
+
     readonly CanCreateBatch: boolean;
     readonly CanCreateCommandBuilder: boolean;
     readonly CanCreateDataAdapter: boolean;
@@ -837,7 +896,6 @@ export interface NpgsqlFactory$instance extends DbProviderFactory {
 
 
 export const NpgsqlFactory: {
-    new(): NpgsqlFactory;
     readonly Instance: NpgsqlFactory;
 };
 
@@ -845,18 +903,20 @@ export const NpgsqlFactory: {
 export type NpgsqlFactory = NpgsqlFactory$instance;
 
 export interface NpgsqlLargeObjectManager$instance {
+    readonly __tsonic_type_Npgsql_NpgsqlLargeObjectManager: never;
+
     readonly Has64BitSupport: boolean;
     MaxTransferBlockSize: int;
     Create(preferredOid?: uint): uint;
-    CreateAsync(preferredOid: uint, cancellationToken?: CancellationToken): Task<System_Internal.UInt32>;
+    CreateAsync(preferredOid: uint, cancellationToken?: CancellationToken): Task_1<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>;
+    OpenReadAsync(oid: uint, cancellationToken?: CancellationToken): Task_1<NpgsqlLargeObjectStream>;
     OpenReadWrite(oid: uint): NpgsqlLargeObjectStream;
-    OpenReadWriteAsync(oid: uint, cancellationToken?: CancellationToken): Task<NpgsqlLargeObjectStream>;
+    OpenReadWriteAsync(oid: uint, cancellationToken?: CancellationToken): Task_1<NpgsqlLargeObjectStream>;
     Unlink(oid: uint): void;
     UnlinkAsync(oid: uint, cancellationToken?: CancellationToken): Task;
 }
@@ -869,12 +929,12 @@ export const NpgsqlLargeObjectManager: {
 
 export type NpgsqlLargeObjectManager = NpgsqlLargeObjectManager$instance;
 
-export abstract class NpgsqlLargeObjectStream$protected {
-    protected Dispose(disposing: boolean): void;
-}
+export interface NpgsqlLargeObjectStream$instance extends Stream {
+    readonly __tsonic_type_Npgsql_NpgsqlLargeObjectStream: never;
 
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlLargeObjectStream$instance extends NpgsqlLargeObjectStream$protected, Stream {
     readonly CanRead: boolean;
     readonly CanSeek: boolean;
     readonly CanTimeout: boolean;
@@ -883,12 +943,13 @@ export interface NpgsqlLargeObjectStream$instance extends NpgsqlLargeObjectStrea
     readonly Length: long;
     Position: long;
     Close(): void;
+    Dispose(disposing: boolean): void;
     Flush(): void;
-    GetLengthAsync(cancellationToken?: CancellationToken): Task<System_Internal.Int64>;
+    GetLengthAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Int64>;
     Read(buffer: byte[], offset: int, count: int): int;
-    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task<System_Internal.Int32>;
+    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<System_Internal.Int32>;
     Seek(offset: long, origin: SeekOrigin): long;
-    SeekAsync(offset: long, origin: SeekOrigin, cancellationToken?: CancellationToken): Task<System_Internal.Int64>;
+    SeekAsync(offset: long, origin: SeekOrigin, cancellationToken?: CancellationToken): Task_1<System_Internal.Int64>;
     SetLength(value: long): void;
     SetLength(value: long, cancellationToken: CancellationToken): Task;
     Write(buffer: byte[], offset: int, count: int): void;
@@ -897,18 +958,18 @@ export interface NpgsqlLargeObjectStream$instance extends NpgsqlLargeObjectStrea
 
 
 export const NpgsqlLargeObjectStream: {
-    new(): NpgsqlLargeObjectStream;
 };
 
 
 export type NpgsqlLargeObjectStream = NpgsqlLargeObjectStream$instance;
 
 export interface NpgsqlLoggingConfiguration$instance {
+    readonly __tsonic_type_Npgsql_NpgsqlLoggingConfiguration: never;
+
 }
 
 
 export const NpgsqlLoggingConfiguration: {
-    new(): NpgsqlLoggingConfiguration;
     InitializeLogging(loggerFactory: ILoggerFactory, parameterLoggingEnabled?: boolean): void;
 };
 
@@ -916,6 +977,8 @@ export const NpgsqlLoggingConfiguration: {
 export type NpgsqlLoggingConfiguration = NpgsqlLoggingConfiguration$instance;
 
 export interface NpgsqlMetricsOptions$instance {
+    readonly __tsonic_type_Npgsql_NpgsqlMetricsOptions: never;
+
 }
 
 
@@ -927,38 +990,45 @@ export const NpgsqlMetricsOptions: {
 export type NpgsqlMetricsOptions = NpgsqlMetricsOptions$instance;
 
 export interface NpgsqlMultiHostDataSource$instance extends NpgsqlDataSource {
+    readonly __tsonic_type_Npgsql_NpgsqlMultiHostDataSource: never;
+
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     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>;
+    OpenConnectionAsync(targetSessionAttributes: TargetSessionAttributes, cancellationToken?: CancellationToken): ValueTask_1<NpgsqlConnection>;
+    OpenConnectionAsync(cancellationToken?: CancellationToken): ValueTask_1<NpgsqlConnection>;
     WithTargetSession(targetSessionAttributes: TargetSessionAttributes): NpgsqlDataSource;
 }
 
 
 export const NpgsqlMultiHostDataSource: {
-    new(): NpgsqlMultiHostDataSource;
 };
 
 
 export type NpgsqlMultiHostDataSource = NpgsqlMultiHostDataSource$instance;
 
-export abstract class NpgsqlNestedDataReader$protected {
-    protected Dispose(disposing: boolean): void;
-    protected GetDbDataReader(ordinal: int): DbDataReader;
-}
+export interface NpgsqlNestedDataReader$instance extends DbDataReader {
+    readonly __tsonic_type_Npgsql_NpgsqlNestedDataReader: never;
 
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Data_IDataReader: never;
+    readonly __tsonic_iface_System_Data_IDataRecord: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlNestedDataReader$instance extends NpgsqlNestedDataReader$protected, DbDataReader {
     readonly Depth: int;
     readonly FieldCount: int;
     readonly HasRows: boolean;
     readonly IsClosed: boolean;
     readonly RecordsAffected: int;
     Close(): void;
+    Dispose(disposing: boolean): void;
     get_Item(ordinal: int): unknown;
     get_Item(name: string): unknown;
     GetBoolean(ordinal: int): boolean;
@@ -969,6 +1039,7 @@ export interface NpgsqlNestedDataReader$instance extends NpgsqlNestedDataReader$
     GetData(ordinal: int): NpgsqlNestedDataReader;
     GetDataTypeName(ordinal: int): string;
     GetDateTime(ordinal: int): DateTime;
+    GetDbDataReader(ordinal: int): DbDataReader;
     GetDecimal(ordinal: int): decimal;
     GetDouble(ordinal: int): double;
     GetEnumerator(): IEnumerator;
@@ -991,25 +1062,27 @@ export interface NpgsqlNestedDataReader$instance extends NpgsqlNestedDataReader$
 
 
 export const NpgsqlNestedDataReader: {
-    new(): NpgsqlNestedDataReader;
 };
 
 
 export type NpgsqlNestedDataReader = NpgsqlNestedDataReader$instance;
 
 export interface NpgsqlNoticeEventArgs$instance extends EventArgs {
+    readonly __tsonic_type_Npgsql_NpgsqlNoticeEventArgs: never;
+
     readonly Notice: PostgresNotice;
 }
 
 
 export const NpgsqlNoticeEventArgs: {
-    new(): NpgsqlNoticeEventArgs;
 };
 
 
 export type NpgsqlNoticeEventArgs = NpgsqlNoticeEventArgs$instance;
 
 export interface NpgsqlNotificationEventArgs$instance extends EventArgs {
+    readonly __tsonic_type_Npgsql_NpgsqlNotificationEventArgs: never;
+
     readonly Channel: string;
     readonly Payload: string;
     readonly PID: int;
@@ -1017,13 +1090,16 @@ export interface NpgsqlNotificationEventArgs$instance extends EventArgs {
 
 
 export const NpgsqlNotificationEventArgs: {
-    new(): NpgsqlNotificationEventArgs;
 };
 
 
 export type NpgsqlNotificationEventArgs = NpgsqlNotificationEventArgs$instance;
 
 export interface NpgsqlOperationInProgressException$instance extends NpgsqlException {
+    readonly __tsonic_type_Npgsql_NpgsqlOperationInProgressException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     readonly CommandInProgress: NpgsqlCommand | undefined;
 }
 
@@ -1036,19 +1112,25 @@ export const NpgsqlOperationInProgressException: {
 export type NpgsqlOperationInProgressException = NpgsqlOperationInProgressException$instance;
 
 export interface NpgsqlParameter$instance extends DbParameter {
+    readonly __tsonic_type_Npgsql_NpgsqlParameter: never;
+
+    readonly __tsonic_iface_System_Data_IDataParameter: never;
+    readonly __tsonic_iface_System_Data_IDbDataParameter: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+
     get Collection(): NpgsqlParameterCollection | undefined;
-    set Collection(value: NpgsqlParameterCollection);
+    set Collection(value: NpgsqlParameterCollection | undefined);
     get DataTypeName(): string | undefined;
-    set DataTypeName(value: string);
+    set DataTypeName(value: string | undefined);
     DbType: DbType;
     Direction: ParameterDirection;
     IsNullable: boolean;
     NpgsqlDbType: NpgsqlDbType;
     get NpgsqlValue(): unknown | undefined;
-    set NpgsqlValue(value: unknown);
+    set NpgsqlValue(value: unknown | undefined);
     ParameterName: string;
     get PostgresType(): PostgresType | undefined;
-    set PostgresType(value: PostgresType);
+    set PostgresType(value: PostgresType | undefined);
     Precision: byte;
     Scale: byte;
     Size: int;
@@ -1056,7 +1138,7 @@ export interface NpgsqlParameter$instance extends DbParameter {
     SourceColumnNullMapping: boolean;
     SourceVersion: DataRowVersion;
     get Value(): unknown | undefined;
-    set Value(value: unknown);
+    set Value(value: unknown | undefined);
     Clone(): NpgsqlParameter;
     ResetDbType(): void;
 }
@@ -1079,9 +1161,15 @@ export const NpgsqlParameter: {
 export type NpgsqlParameter = NpgsqlParameter$instance;
 
 export interface NpgsqlParameter_1$instance<T> extends NpgsqlParameter {
+    readonly __tsonic_type_Npgsql_NpgsqlParameter_1: never;
+
+    readonly __tsonic_iface_System_Data_IDataParameter: never;
+    readonly __tsonic_iface_System_Data_IDbDataParameter: never;
+    readonly __tsonic_iface_System_ICloneable: never;
+
     TypedValue: T | undefined;
     get Value(): unknown | undefined;
-    set Value(value: unknown);
+    set Value(value: unknown | undefined);
 }
 
 
@@ -1095,15 +1183,17 @@ export const NpgsqlParameter_1: {
 
 export type NpgsqlParameter_1<T> = NpgsqlParameter_1$instance<T>;
 
-export abstract class NpgsqlParameterCollection$protected {
-    protected GetParameter(parameterName: string): DbParameter;
-    protected GetParameter(index: int): DbParameter;
-    protected SetParameter(parameterName: string, value: DbParameter): void;
-    protected SetParameter(index: int, value: DbParameter): void;
-}
+export interface NpgsqlParameterCollection$instance extends DbParameterCollection {
+    readonly __tsonic_type_Npgsql_NpgsqlParameterCollection: never;
 
+    readonly __tsonic_iface_System_Collections_Generic_ICollection_1: never;
+    readonly __tsonic_iface_System_Collections_Generic_IEnumerable_1: never;
+    readonly __tsonic_iface_System_Collections_Generic_IList_1: never;
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Collections_IList: never;
+    readonly __tsonic_iface_System_Data_IDataParameterCollection: never;
 
-export interface NpgsqlParameterCollection$instance extends NpgsqlParameterCollection$protected, DbParameterCollection {
     readonly Count: int;
     readonly IsFixedSize: boolean;
     readonly IsReadOnly: boolean;
@@ -1130,6 +1220,8 @@ export interface NpgsqlParameterCollection$instance extends NpgsqlParameterColle
     get_Item(parameterName: string): NpgsqlParameter;
     get_Item(index: int): NpgsqlParameter;
     GetEnumerator(): IEnumerator;
+    GetParameter(parameterName: string): DbParameter;
+    GetParameter(index: int): DbParameter;
     IndexOf(parameterName: string): int;
     IndexOf(value: unknown): int;
     IndexOf(item: NpgsqlParameter): int;
@@ -1142,24 +1234,26 @@ export interface NpgsqlParameterCollection$instance extends NpgsqlParameterColle
     RemoveAt(index: int): void;
     set_Item(parameterName: string, value: NpgsqlParameter): void;
     set_Item(index: int, value: NpgsqlParameter): void;
+    SetParameter(parameterName: string, value: DbParameter): void;
+    SetParameter(index: int, value: DbParameter): void;
     ToArray(): NpgsqlParameter[];
     TryGetValue(parameterName: string, parameter: NpgsqlParameter): boolean;
 }
 
 
 export const NpgsqlParameterCollection: {
-    new(): NpgsqlParameterCollection;
 };
 
 
 export type NpgsqlParameterCollection = NpgsqlParameterCollection$instance;
 
-export abstract class NpgsqlRawCopyStream$protected {
-    protected Dispose(disposing: boolean): void;
-}
+export interface NpgsqlRawCopyStream$instance extends Stream {
+    readonly __tsonic_type_Npgsql_NpgsqlRawCopyStream: never;
 
+    readonly __tsonic_iface_Npgsql_ICancelable: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlRawCopyStream$instance extends NpgsqlRawCopyStream$protected, Stream {
     readonly CanRead: boolean;
     readonly CanSeek: boolean;
     readonly CanTimeout: boolean;
@@ -1170,30 +1264,32 @@ export interface NpgsqlRawCopyStream$instance extends NpgsqlRawCopyStream$protec
     WriteTimeout: int;
     Cancel(): void;
     CancelAsync(): Task;
+    Dispose(disposing: boolean): void;
     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>;
+    Read(span: Span_1<System_Internal.Byte>): int;
+    ReadAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task_1<System_Internal.Int32>;
+    ReadAsync(buffer: Memory_1<System_Internal.Byte>, cancellationToken: CancellationToken): ValueTask_1<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;
+    Write(buffer: ReadOnlySpan_1<System_Internal.Byte>): void;
     WriteAsync(buffer: byte[], offset: int, count: int, cancellationToken: CancellationToken): Task;
-    WriteAsync(buffer: ReadOnlyMemory<System_Internal.Byte>, cancellationToken?: CancellationToken): ValueTask;
+    WriteAsync(buffer: ReadOnlyMemory_1<System_Internal.Byte>, cancellationToken?: CancellationToken): ValueTask;
 }
 
 
 export const NpgsqlRawCopyStream: {
-    new(): NpgsqlRawCopyStream;
 };
 
 
 export type NpgsqlRawCopyStream = NpgsqlRawCopyStream$instance;
 
 export interface NpgsqlRowUpdatedEventArgs$instance extends RowUpdatedEventArgs {
+    readonly __tsonic_type_Npgsql_NpgsqlRowUpdatedEventArgs: never;
+
 }
 
 
@@ -1205,6 +1301,8 @@ export const NpgsqlRowUpdatedEventArgs: {
 export type NpgsqlRowUpdatedEventArgs = NpgsqlRowUpdatedEventArgs$instance;
 
 export interface NpgsqlRowUpdatingEventArgs$instance extends RowUpdatingEventArgs {
+    readonly __tsonic_type_Npgsql_NpgsqlRowUpdatingEventArgs: never;
+
 }
 
 
@@ -1216,16 +1314,21 @@ export const NpgsqlRowUpdatingEventArgs: {
 export type NpgsqlRowUpdatingEventArgs = NpgsqlRowUpdatingEventArgs$instance;
 
 export interface NpgsqlSlimDataSourceBuilder$instance {
+    readonly __tsonic_type_Npgsql_NpgsqlSlimDataSourceBuilder: never;
+
+    readonly __tsonic_iface_Npgsql_TypeMapping_INpgsqlTypeMapper: never;
+
     readonly ConnectionString: string;
     readonly ConnectionStringBuilder: NpgsqlConnectionStringBuilder;
     DefaultNameTranslator: INpgsqlNameTranslator;
-    Name: string;
+    get Name(): string | undefined;
+    set Name(value: string | undefined);
     AddTypeInfoResolverFactory(factory: PgTypeInfoResolverFactory): void;
     Build(): NpgsqlDataSource;
     BuildMultiHost(): NpgsqlMultiHostDataSource;
     ConfigureJsonOptions(serializerOptions: JsonSerializerOptions): NpgsqlSlimDataSourceBuilder;
-    ConfigureTracing(configureAction: Action<NpgsqlTracingOptionsBuilder>): NpgsqlSlimDataSourceBuilder;
-    ConfigureTypeLoading(configureAction: Action<NpgsqlTypeLoadingOptionsBuilder>): NpgsqlSlimDataSourceBuilder;
+    ConfigureTracing(configureAction: Action_1<NpgsqlTracingOptionsBuilder>): NpgsqlSlimDataSourceBuilder;
+    ConfigureTypeLoading(configureAction: Action_1<NpgsqlTypeLoadingOptionsBuilder>): NpgsqlSlimDataSourceBuilder;
     EnableArrays(): NpgsqlSlimDataSourceBuilder;
     EnableCube(): NpgsqlSlimDataSourceBuilder;
     EnableDynamicJson(jsonbClrTypes?: Type[], jsonClrTypes?: Type[]): NpgsqlSlimDataSourceBuilder;
@@ -1253,17 +1356,17 @@ export interface NpgsqlSlimDataSourceBuilder$instance {
     UnmapEnum(clrType: Type, pgName?: string, nameTranslator?: INpgsqlNameTranslator): boolean;
     UseClientCertificate(clientCertificate: X509Certificate): NpgsqlSlimDataSourceBuilder;
     UseClientCertificates(clientCertificates: X509CertificateCollection): NpgsqlSlimDataSourceBuilder;
-    UseClientCertificatesCallback(clientCertificatesCallback: Action<X509CertificateCollection>): NpgsqlSlimDataSourceBuilder;
+    UseClientCertificatesCallback(clientCertificatesCallback: Action_1<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;
+    UseNegotiateOptionsCallback(negotiateOptionsCallback: Action_1<NegotiateAuthenticationClientOptions>): NpgsqlSlimDataSourceBuilder;
+    UsePasswordProvider(passwordProvider: Func_2<NpgsqlConnectionStringBuilder, System_Internal.String>, passwordProviderAsync: Func_3<NpgsqlConnectionStringBuilder, CancellationToken, ValueTask_1<System_Internal.String>>): NpgsqlSlimDataSourceBuilder;
+    UsePeriodicPasswordProvider(passwordProvider: Func_3<NpgsqlConnectionStringBuilder, CancellationToken, ValueTask_1<System_Internal.String>>, successRefreshInterval: TimeSpan, failureRefreshInterval: TimeSpan): NpgsqlSlimDataSourceBuilder;
+    UsePhysicalConnectionInitializer(connectionInitializer: Action_1<NpgsqlConnection>, connectionInitializerAsync: Func_2<NpgsqlConnection, Task>): NpgsqlSlimDataSourceBuilder;
     UseRootCertificate(rootCertificate: X509Certificate2): NpgsqlSlimDataSourceBuilder;
-    UseRootCertificateCallback(rootCertificateCallback: Func<X509Certificate2>): NpgsqlSlimDataSourceBuilder;
+    UseRootCertificateCallback(rootCertificateCallback: Func_1<X509Certificate2>): NpgsqlSlimDataSourceBuilder;
     UseRootCertificates(rootCertificates: X509Certificate2Collection): NpgsqlSlimDataSourceBuilder;
-    UseRootCertificatesCallback(rootCertificateCallback: Func<X509Certificate2Collection>): NpgsqlSlimDataSourceBuilder;
-    UseSslClientAuthenticationOptionsCallback(sslClientAuthenticationOptionsCallback: Action<SslClientAuthenticationOptions>): NpgsqlSlimDataSourceBuilder;
+    UseRootCertificatesCallback(rootCertificateCallback: Func_1<X509Certificate2Collection>): NpgsqlSlimDataSourceBuilder;
+    UseSslClientAuthenticationOptionsCallback(sslClientAuthenticationOptionsCallback: Action_1<SslClientAuthenticationOptions>): NpgsqlSlimDataSourceBuilder;
     UseUserCertificateValidationCallback(userCertificateValidationCallback: RemoteCertificateValidationCallback): NpgsqlSlimDataSourceBuilder;
 }
 
@@ -1281,39 +1384,42 @@ export type NpgsqlSlimDataSourceBuilder = NpgsqlSlimDataSourceBuilder$instance &
 
 
 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;
+    readonly __tsonic_type_Npgsql_NpgsqlTracingOptionsBuilder: never;
+
+    ConfigureBatchEnrichmentCallback(batchEnrichmentCallback: Action_2<Activity, NpgsqlBatch>): NpgsqlTracingOptionsBuilder;
+    ConfigureBatchFilter(batchFilter: Func_2<NpgsqlBatch, System_Internal.Boolean>): NpgsqlTracingOptionsBuilder;
+    ConfigureBatchSpanNameProvider(batchSpanNameProvider: Func_2<NpgsqlBatch, System_Internal.String>): NpgsqlTracingOptionsBuilder;
+    ConfigureCommandEnrichmentCallback(commandEnrichmentCallback: Action_2<Activity, NpgsqlCommand>): NpgsqlTracingOptionsBuilder;
+    ConfigureCommandFilter(commandFilter: Func_2<NpgsqlCommand, System_Internal.Boolean>): NpgsqlTracingOptionsBuilder;
+    ConfigureCommandSpanNameProvider(commandSpanNameProvider: Func_2<NpgsqlCommand, System_Internal.String>): NpgsqlTracingOptionsBuilder;
+    ConfigureCopyOperationEnrichmentCallback(copyOperationEnrichmentCallback: Action_2<Activity, System_Internal.String>): NpgsqlTracingOptionsBuilder;
+    ConfigureCopyOperationFilter(copyOperationFilter: Func_2<System_Internal.String, System_Internal.Boolean>): NpgsqlTracingOptionsBuilder;
+    ConfigureCopyOperationSpanNameProvider(copyOperationSpanNameProvider: Func_2<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 abstract class NpgsqlTransaction$protected {
-    protected readonly DbConnection: DbConnection;
-    protected Dispose(disposing: boolean): void;
-}
+export interface NpgsqlTransaction$instance extends DbTransaction {
+    readonly __tsonic_type_Npgsql_NpgsqlTransaction: never;
 
+    readonly __tsonic_iface_System_Data_IDbTransaction: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface NpgsqlTransaction$instance extends NpgsqlTransaction$protected, DbTransaction {
     readonly Connection: NpgsqlConnection | undefined;
+    readonly DbConnection: DbConnection | undefined;
     readonly IsolationLevel: IsolationLevel;
     readonly SupportsSavepoints: boolean;
     Commit(): void;
     CommitAsync(cancellationToken?: CancellationToken): Task;
+    Dispose(disposing: boolean): void;
     DisposeAsync(): ValueTask;
     Release(name: string): void;
     ReleaseAsync(name: string, cancellationToken?: CancellationToken): Task;
@@ -1327,27 +1433,31 @@ export interface NpgsqlTransaction$instance extends NpgsqlTransaction$protected,
 
 
 export const NpgsqlTransaction: {
-    new(): NpgsqlTransaction;
 };
 
 
 export type NpgsqlTransaction = NpgsqlTransaction$instance;
 
 export interface NpgsqlTypeLoadingOptionsBuilder$instance {
+    readonly __tsonic_type_Npgsql_NpgsqlTypeLoadingOptionsBuilder: never;
+
     EnableTableCompositesLoading(enable?: boolean): NpgsqlTypeLoadingOptionsBuilder;
     EnableTypeLoading(enable?: boolean): NpgsqlTypeLoadingOptionsBuilder;
-    SetTypeLoadingSchemas(schemas: IEnumerable__System_Collections_Generic<System_Internal.String>): NpgsqlTypeLoadingOptionsBuilder;
+    SetTypeLoadingSchemas(schemas: IEnumerable_1<System_Internal.String>): NpgsqlTypeLoadingOptionsBuilder;
 }
 
 
 export const NpgsqlTypeLoadingOptionsBuilder: {
-    new(): NpgsqlTypeLoadingOptionsBuilder;
 };
 
 
 export type NpgsqlTypeLoadingOptionsBuilder = NpgsqlTypeLoadingOptionsBuilder$instance;
 
 export interface PostgresException$instance extends NpgsqlException {
+    readonly __tsonic_type_Npgsql_PostgresException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     readonly ColumnName: string | undefined;
     readonly ConstraintName: string | undefined;
     readonly DataTypeName: string | undefined;
@@ -1381,36 +1491,38 @@ export const PostgresException: {
 export type PostgresException = PostgresException$instance;
 
 export interface PostgresNotice$instance {
+    readonly __tsonic_type_Npgsql_PostgresNotice: never;
+
     get ColumnName(): string | undefined;
-    set ColumnName(value: string);
+    set ColumnName(value: string | undefined);
     get ConstraintName(): string | undefined;
-    set ConstraintName(value: string);
+    set ConstraintName(value: string | undefined);
     get DataTypeName(): string | undefined;
-    set DataTypeName(value: string);
+    set DataTypeName(value: string | undefined);
     get Detail(): string | undefined;
-    set Detail(value: string);
+    set Detail(value: string | undefined);
     get File(): string | undefined;
-    set File(value: string);
+    set File(value: string | undefined);
     get Hint(): string | undefined;
-    set Hint(value: string);
+    set Hint(value: string | undefined);
     InternalPosition: int;
     get InternalQuery(): string | undefined;
-    set InternalQuery(value: string);
+    set InternalQuery(value: string | undefined);
     readonly InvariantSeverity: string;
     get Line(): string | undefined;
-    set Line(value: string);
+    set Line(value: string | undefined);
     MessageText: string;
     Position: int;
     get Routine(): string | undefined;
-    set Routine(value: string);
+    set Routine(value: string | undefined);
     get SchemaName(): string | undefined;
-    set SchemaName(value: string);
+    set SchemaName(value: string | undefined);
     Severity: string;
     SqlState: string;
     get TableName(): string | undefined;
-    set TableName(value: string);
+    set TableName(value: string | undefined);
     get Where(): string | undefined;
-    set Where(value: string);
+    set Where(value: string | undefined);
 }