@tsonic/efcore-npgsql 10.0.2 → 10.0.7

package/Npgsql.Internal/internal/index.d.ts

@@ -14,17 +14,17 @@ import type { PostgresType } from "../../Npgsql.PostgresTypes/internal/index.js"
 import type { NpgsqlTimeout } from "../../Npgsql.Util/internal/index.js";
 import type { ArrayNullabilityMode, INpgsqlNameTranslator, NpgsqlBatch, NpgsqlCommand, NpgsqlConnectionStringBuilder } from "../../Npgsql/internal/index.js";
 import type { NpgsqlRange_1 } from "../../NpgsqlTypes/internal/index.js";
-import type { ReadOnlySequence } from "@tsonic/dotnet/System.Buffers.js";
-import type { IEnumerable, IReadOnlyList, List } from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { DbType } from "@tsonic/dotnet/System.Data.js";
-import type { Stream, TextReader } from "@tsonic/dotnet/System.IO.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { ArgumentOutOfRangeException, AsyncCallback, Boolean as ClrBoolean, Byte, Char, Double, Enum, Func, IAsyncDisposable, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IEquatable, IFormattable, Int16, Int32, Int64, IntPtr, ISpanFormattable, Memory, MulticastDelegate, Nullable, Object as ClrObject, ReadOnlyMemory, ReadOnlySpan, Single, Span, String as ClrString, TimeSpan, Type, UInt16, UInt32, UInt64, ValueType, Version, Void } from "@tsonic/dotnet/System.js";
-import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization.js";
-import type { ISerializable } from "@tsonic/dotnet/System.Runtime.Serialization.js";
-import type { Encoding } from "@tsonic/dotnet/System.Text.js";
-import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
-import type { Task, ValueTask } from "@tsonic/dotnet/System.Threading.Tasks.js";
+import type { ReadOnlySequence_1 } from "@tsonic/dotnet/System.Buffers/internal/index.js";
+import type { IEnumerable_1, IReadOnlyList_1, List_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { DbType } from "@tsonic/dotnet/System.Data/internal/index.js";
+import type { Stream, TextReader } from "@tsonic/dotnet/System.IO/internal/index.js";
+import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
+import type { ISerializable } from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
+import type { Encoding } from "@tsonic/dotnet/System.Text/internal/index.js";
+import type { 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 * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { ArgumentOutOfRangeException, AsyncCallback, Boolean as ClrBoolean, Byte, Char, Double, Enum, Func_1, Func_2, IAsyncDisposable, IAsyncResult, ICloneable, IComparable, IConvertible, IDisposable, IEquatable_1, IFormattable, Int16, Int32, Int64, IntPtr, ISpanFormattable, Memory_1, MulticastDelegate, Nullable_1, Object as ClrObject, ReadOnlyMemory_1, ReadOnlySpan_1, Single, Span_1, String as ClrString, TimeSpan, Type, UInt16, UInt32, UInt64, ValueType, Version, Void } from "@tsonic/dotnet/System/internal/index.js";
 
 export enum DataFormat {
     Binary = 0,
@@ -50,28 +50,38 @@ export type TypeInfoFactory = (options: PgSerializerOptions, mapping: TypeInfoMa
 
 
 export interface IDbTypeResolver$instance {
+    readonly __tsonic_iface_Npgsql_Internal_IDbTypeResolver: never;
+
     GetDataTypeName(dbType: DbType, type: Type): string | undefined;
-    GetDbType(dataTypeName: DataTypeName): Nullable<DbType>;
+    GetDbType(dataTypeName: DataTypeName): Nullable_1<DbType>;
 }
 
 
 export type IDbTypeResolver = IDbTypeResolver$instance;
 
 export interface INpgsqlDatabaseInfoFactory$instance {
-    Load(conn: NpgsqlConnector, timeout: NpgsqlTimeout, async: boolean): Task<NpgsqlDatabaseInfo | undefined>;
+    readonly __tsonic_iface_Npgsql_Internal_INpgsqlDatabaseInfoFactory: never;
+
+    Load(conn: NpgsqlConnector, timeout: NpgsqlTimeout, async: boolean): Task_1<NpgsqlDatabaseInfo | undefined>;
 }
 
 
 export type INpgsqlDatabaseInfoFactory = INpgsqlDatabaseInfoFactory$instance;
 
 export interface IPgTypeInfoResolver$instance {
-    GetTypeInfo(type: Type, dataTypeName: Nullable<DataTypeName>, options: PgSerializerOptions): PgTypeInfo | undefined;
+    readonly __tsonic_iface_Npgsql_Internal_IPgTypeInfoResolver: never;
+
+    GetTypeInfo(type: Type, dataTypeName: Nullable_1<DataTypeName>, options: PgSerializerOptions): PgTypeInfo | undefined;
 }
 
 
 export type IPgTypeInfoResolver = IPgTypeInfoResolver$instance;
 
 export interface BufferRequirements$instance {
+    readonly __tsonic_type_Npgsql_Internal_BufferRequirements: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly Read: Size;
     readonly Write: Size;
     Combine(read: Size, write: Size): BufferRequirements;
@@ -96,6 +106,11 @@ export const BufferRequirements: {
 export type BufferRequirements = BufferRequirements$instance;
 
 export interface NestedReadScope$instance {
+    readonly __tsonic_type_Npgsql_Internal_NestedReadScope: never;
+
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(): void;
     DisposeAsync(): ValueTask;
 }
@@ -109,6 +124,10 @@ export const NestedReadScope: {
 export type NestedReadScope = NestedReadScope$instance;
 
 export interface NestedWriteScope$instance {
+    readonly __tsonic_type_Npgsql_Internal_NestedWriteScope: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(): void;
 }
 
@@ -121,6 +140,8 @@ export const NestedWriteScope: {
 export type NestedWriteScope = NestedWriteScope$instance;
 
 export interface PgConverterResolution$instance {
+    readonly __tsonic_type_Npgsql_Internal_PgConverterResolution: never;
+
     readonly Converter: PgConverter;
     readonly PgTypeId: PgTypeId;
     GetConverter<T>(): PgConverter_1<T>;
@@ -135,6 +156,10 @@ export const PgConverterResolution: {
 export type PgConverterResolution = PgConverterResolution$instance;
 
 export interface Size$instance {
+    readonly __tsonic_type_Npgsql_Internal_Size: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly Kind: SizeKind;
     readonly Value: int;
     Combine(other: Size): Size;
@@ -158,6 +183,8 @@ export const Size: {
 export type Size = Size$instance;
 
 export interface SizeContext$instance {
+    readonly __tsonic_type_Npgsql_Internal_SizeContext: never;
+
     BufferRequirement: Size;
     readonly Format: DataFormat;
 }
@@ -171,12 +198,14 @@ export const SizeContext: {
 export type SizeContext = SizeContext$instance;
 
 export interface TypeInfoMapping$instance {
+    readonly __tsonic_type_Npgsql_Internal_TypeInfoMapping: never;
+
     DataTypeName: string;
     Factory: TypeInfoFactory;
     MatchRequirement: MatchRequirement;
     Type: Type;
-    get TypeMatchPredicate(): Func<Type | undefined, System_Internal.Boolean> | undefined;
-    set TypeMatchPredicate(value: Func<Type | undefined, System_Internal.Boolean>);
+    get TypeMatchPredicate(): Func_2<Type | undefined, System_Internal.Boolean> | undefined;
+    set TypeMatchPredicate(value: Func_2<Type | undefined, System_Internal.Boolean> | undefined);
     DataTypeNameEquals(dataTypeName: string): boolean;
     TypeEquals(type: Type): boolean;
 }
@@ -190,11 +219,13 @@ export const TypeInfoMapping: {
 export type TypeInfoMapping = TypeInfoMapping$instance;
 
 export interface ValueMetadata$instance {
+    readonly __tsonic_type_Npgsql_Internal_ValueMetadata: never;
+
     BufferRequirement: Size;
     Format: DataFormat;
     Size: Size;
     get WriteState(): unknown | undefined;
-    set WriteState(value: unknown);
+    set WriteState(value: unknown | undefined);
 }
 
 
@@ -206,33 +237,33 @@ export const ValueMetadata: {
 export type ValueMetadata = ValueMetadata$instance;
 
 export interface DbTypeResolverFactory$instance {
+    readonly __tsonic_type_Npgsql_Internal_DbTypeResolverFactory: never;
+
     CreateDbTypeResolver(databaseInfo: NpgsqlDatabaseInfo): IDbTypeResolver;
 }
 
 
-export const DbTypeResolverFactory: {
-    new(): DbTypeResolverFactory;
+export const DbTypeResolverFactory: (abstract new() => DbTypeResolverFactory) & {
 };
 
 
 export type DbTypeResolverFactory = DbTypeResolverFactory$instance;
 
-export abstract class DynamicTypeInfoResolver$protected {
-    protected abstract GetMappings(type: Type, dataTypeName: DataTypeName, options: PgSerializerOptions): DynamicTypeInfoResolver_DynamicMappingCollection | undefined;
-}
+export interface DynamicTypeInfoResolver$instance extends IPgTypeInfoResolver$instance {
+    readonly __tsonic_type_Npgsql_Internal_DynamicTypeInfoResolver: never;
 
+    readonly __tsonic_iface_Npgsql_Internal_IPgTypeInfoResolver: never;
 
-export interface DynamicTypeInfoResolver$instance extends DynamicTypeInfoResolver$protected {
-    GetTypeInfo(type: Type, dataTypeName: Nullable<DataTypeName>, options: PgSerializerOptions): PgTypeInfo | undefined;
+    GetMappings(type: Type, dataTypeName: DataTypeName, options: PgSerializerOptions): unknown | undefined;
+    GetTypeInfo(type: Type, dataTypeName: Nullable_1<DataTypeName>, options: PgSerializerOptions): PgTypeInfo | undefined;
 }
 
 
-export const DynamicTypeInfoResolver: {
-    new(): DynamicTypeInfoResolver;
-    CreateCollection(baseCollection?: TypeInfoMappingCollection): DynamicTypeInfoResolver_DynamicMappingCollection;
+export const DynamicTypeInfoResolver: (abstract new() => DynamicTypeInfoResolver) & {
+    CreateCollection(baseCollection?: TypeInfoMappingCollection): unknown;
     IsArrayDataTypeName(dataTypeName: DataTypeName, options: PgSerializerOptions, elementDataTypeName: DataTypeName): boolean;
     IsArrayLikeType(type: Type, elementType: Type): boolean;
-    IsTypeOrNullableOfType(type: Type, predicate: Func<Type, System_Internal.Boolean>, matchedType: Type): boolean;
+    IsTypeOrNullableOfType(type: Type, predicate: Func_2<Type, System_Internal.Boolean>, matchedType: Type): boolean;
 };
 
 
@@ -240,12 +271,12 @@ export interface __DynamicTypeInfoResolver$views {
     As_IPgTypeInfoResolver(): IPgTypeInfoResolver$instance;
 }
 
-export interface DynamicTypeInfoResolver$instance extends IPgTypeInfoResolver$instance {}
-
 export type DynamicTypeInfoResolver = DynamicTypeInfoResolver$instance & __DynamicTypeInfoResolver$views;
 
 
 export interface NpgsqlConnector$instance {
+    readonly __tsonic_type_Npgsql_Internal_NpgsqlConnector: never;
+
     readonly DatabaseInfo: NpgsqlDatabaseInfo;
     readonly Settings: NpgsqlConnectionStringBuilder;
     TextEncoding: Encoding;
@@ -255,18 +286,14 @@ export interface NpgsqlConnector$instance {
 
 
 export const NpgsqlConnector: {
-    new(): NpgsqlConnector;
 };
 
 
 export type NpgsqlConnector = NpgsqlConnector$instance;
 
-export abstract class NpgsqlDatabaseInfo$protected {
-    protected abstract GetTypes(): IEnumerable<PostgresType>;
-}
-
+export interface NpgsqlDatabaseInfo$instance {
+    readonly __tsonic_type_Npgsql_Internal_NpgsqlDatabaseInfo: never;
 
-export interface NpgsqlDatabaseInfo$instance extends NpgsqlDatabaseInfo$protected {
     HasIntegerDateTimes: boolean;
     readonly Host: string;
     readonly Name: string;
@@ -285,13 +312,12 @@ export interface NpgsqlDatabaseInfo$instance extends NpgsqlDatabaseInfo$protecte
     readonly Version: Version;
     GetPostgresType(oid: uint): PostgresType;
     GetPostgresType(pgName: string): PostgresType;
+    GetTypes(): IEnumerable_1<PostgresType>;
     TryGetPostgresTypeByName(pgName: string, pgType: PostgresType): boolean;
 }
 
 
-export const NpgsqlDatabaseInfo: {
-    new(host: string, port: int, databaseName: string, version: Version): NpgsqlDatabaseInfo;
-    new(host: string, port: int, databaseName: string, version: Version, serverVersion: string): NpgsqlDatabaseInfo;
+export const NpgsqlDatabaseInfo: (abstract new(host: string, port: int, databaseName: string, version: Version) => NpgsqlDatabaseInfo) & (abstract new(host: string, port: int, databaseName: string, version: Version, serverVersion: string) => NpgsqlDatabaseInfo) & {
     ParseServerVersion(value: string): Version;
     RegisterFactory(factory: INpgsqlDatabaseInfoFactory): void;
 };
@@ -299,30 +325,29 @@ export const NpgsqlDatabaseInfo: {
 
 export type NpgsqlDatabaseInfo = NpgsqlDatabaseInfo$instance;
 
-export abstract class PgBufferedConverter_1$protected<T> {
-    protected abstract ReadCore(reader: PgReader): T;
-    protected abstract WriteCore(writer: PgWriter, value: T): void;
-}
-
+export interface PgBufferedConverter_1$instance<T> extends PgConverter_1<T> {
+    readonly __tsonic_type_Npgsql_Internal_PgBufferedConverter_1: never;
 
-export interface PgBufferedConverter_1$instance<T> extends PgBufferedConverter_1$protected<T>, PgConverter_1<T> {
     GetSize(context: SizeContext, value: T, writeState: unknown): Size;
     Read(reader: PgReader): T;
-    ReadAsync(reader: PgReader, cancellationToken?: CancellationToken): ValueTask<T>;
-    ReadAsync(reader: PgReader, cancellationToken?: CancellationToken): ValueTask<T>;
+    ReadAsync(reader: PgReader, cancellationToken?: CancellationToken): ValueTask_1<T>;
+    ReadAsync(reader: PgReader, cancellationToken?: CancellationToken): ValueTask_1<T>;
+    ReadCore(reader: PgReader): T;
     Write(writer: PgWriter, value: T): void;
     WriteAsync(writer: PgWriter, value: T, cancellationToken?: CancellationToken): ValueTask;
+    WriteCore(writer: PgWriter, value: T): void;
 }
 
 
-export const PgBufferedConverter_1: {
-    new<T>(customDbNullPredicate: boolean): PgBufferedConverter_1<T>;
+export const PgBufferedConverter_1: (abstract new<T>(customDbNullPredicate: boolean) => PgBufferedConverter_1<T>) & {
 };
 
 
 export type PgBufferedConverter_1<T> = PgBufferedConverter_1$instance<T>;
 
 export interface PgConverter$instance {
+    readonly __tsonic_type_Npgsql_Internal_PgConverter: never;
+
     readonly IsDbNullable: boolean;
     CanConvert(format: DataFormat, bufferRequirements: BufferRequirements): boolean;
 }
@@ -334,16 +359,14 @@ export const PgConverter: {
 
 export type PgConverter = PgConverter$instance;
 
-export abstract class PgConverter_1$protected<T> {
-    protected IsDbNullValue(value: T, writeState: unknown): boolean;
-}
-
+export interface PgConverter_1$instance<T> extends PgConverter {
+    readonly __tsonic_type_Npgsql_Internal_PgConverter_1: never;
 
-export interface PgConverter_1$instance<T> extends PgConverter_1$protected<T>, PgConverter {
     GetSize(context: SizeContext, value: T, writeState: unknown): Size;
     IsDbNull(value: T, writeState: unknown): boolean;
+    IsDbNullValue(value: T, writeState: unknown): boolean;
     Read(reader: PgReader): T;
-    ReadAsync(reader: PgReader, cancellationToken?: CancellationToken): ValueTask<T>;
+    ReadAsync(reader: PgReader, cancellationToken?: CancellationToken): ValueTask_1<T>;
     Write(writer: PgWriter, value: T): void;
     WriteAsync(writer: PgWriter, value: T, cancellationToken?: CancellationToken): ValueTask;
 }
@@ -356,8 +379,10 @@ export const PgConverter_1: {
 export type PgConverter_1<T> = PgConverter_1$instance<T>;
 
 export interface PgConverterResolver$instance {
+    readonly __tsonic_type_Npgsql_Internal_PgConverterResolver: never;
+
     Get(field: Field): PgConverterResolution;
-    GetDefault(pgTypeId: Nullable<PgTypeId>): PgConverterResolution;
+    GetDefault(pgTypeId: Nullable_1<PgTypeId>): PgConverterResolution;
 }
 
 
@@ -368,82 +393,88 @@ export const PgConverterResolver: {
 export type PgConverterResolver = PgConverterResolver$instance;
 
 export interface PgConverterResolver_1$instance<T> extends PgConverterResolver {
-    Get(value: T, expectedPgTypeId: Nullable<PgTypeId>): Nullable<PgConverterResolution>;
+    readonly __tsonic_type_Npgsql_Internal_PgConverterResolver_1: never;
+
+    Get(value: T, expectedPgTypeId: Nullable_1<PgTypeId>): Nullable_1<PgConverterResolution>;
     Get(field: Field): PgConverterResolution;
 }
 
 
-export const PgConverterResolver_1: {
-    new<T>(): PgConverterResolver_1<T>;
+export const PgConverterResolver_1: (abstract new<T>() => PgConverterResolver_1<T>) & {
 };
 
 
 export type PgConverterResolver_1<T> = PgConverterResolver_1$instance<T>;
 
 export interface PgReader$instance {
+    readonly __tsonic_type_Npgsql_Internal_PgReader: never;
+
     readonly Current: ValueMetadata;
     readonly CurrentRemaining: int;
     readonly IsResumed: boolean;
     BeginNestedRead(size: int, bufferRequirement: Size): NestedReadScope;
-    BeginNestedReadAsync(size: int, bufferRequirement: Size, cancellationToken?: CancellationToken): ValueTask<NestedReadScope>;
+    BeginNestedReadAsync(size: int, bufferRequirement: Size, cancellationToken?: CancellationToken): ValueTask_1<NestedReadScope>;
     Buffer(bufferRequirement: Size): void;
     Buffer(byteCount: int): void;
     BufferAsync(bufferRequirement: Size, cancellationToken: CancellationToken): ValueTask;
     BufferAsync(byteCount: int, cancellationToken: CancellationToken): ValueTask;
-    Consume(count?: Nullable<System_Internal.Int32>): void;
-    ConsumeAsync(count?: Nullable<System_Internal.Int32>, cancellationToken?: CancellationToken): ValueTask;
-    GetStream(length?: Nullable<System_Internal.Int32>): Stream;
+    Consume(count?: Nullable_1<System_Internal.Int32>): void;
+    ConsumeAsync(count?: Nullable_1<System_Internal.Int32>, cancellationToken?: CancellationToken): ValueTask;
+    GetStream(length?: Nullable_1<System_Internal.Int32>): Stream;
     GetTextReader(encoding: Encoding): TextReader;
-    GetTextReaderAsync(encoding: Encoding, cancellationToken: CancellationToken): ValueTask<TextReader>;
-    Read(destination: Span<System_Internal.Byte>): void;
+    GetTextReaderAsync(encoding: Encoding, cancellationToken: CancellationToken): ValueTask_1<TextReader>;
+    Read(destination: Span_1<System_Internal.Byte>): void;
     ReadByte(): byte;
-    ReadBytes(buffer: Span<System_Internal.Byte>): void;
-    ReadBytes(count: int): ReadOnlySequence<System_Internal.Byte>;
-    ReadBytesAsync(buffer: Memory<System_Internal.Byte>, cancellationToken?: CancellationToken): ValueTask;
-    ReadBytesAsync(count: int, cancellationToken?: CancellationToken): ValueTask<ReadOnlySequence<System_Internal.Byte>>;
+    ReadBytes(buffer: Span_1<System_Internal.Byte>): void;
+    ReadBytes(count: int): ReadOnlySequence_1<System_Internal.Byte>;
+    ReadBytesAsync(buffer: Memory_1<System_Internal.Byte>, cancellationToken?: CancellationToken): ValueTask;
+    ReadBytesAsync(count: int, cancellationToken?: CancellationToken): ValueTask_1<ReadOnlySequence_1<System_Internal.Byte>>;
     ReadDouble(): double;
     ReadFloat(): float;
     ReadInt16(): short;
     ReadInt32(): int;
     ReadInt64(): long;
     ReadNullTerminatedString(encoding: Encoding): string;
-    ReadNullTerminatedStringAsync(encoding: Encoding, cancellationToken?: CancellationToken): ValueTask<System_Internal.String>;
+    ReadNullTerminatedStringAsync(encoding: Encoding, cancellationToken?: CancellationToken): ValueTask_1<System_Internal.String>;
     ReadUInt16(): ushort;
     ReadUInt32(): uint;
     ReadUInt64(): ulong;
     Rewind(count: int): void;
     ShouldBuffer(bufferRequirement: Size): boolean;
     ShouldBuffer(byteCount: int): boolean;
-    TryReadBytes(count: int, bytes: ReadOnlySpan<System_Internal.Byte>): boolean;
-    TryReadBytes(count: int, bytes: ReadOnlyMemory<System_Internal.Byte>): boolean;
+    TryReadBytes(count: int, bytes: ReadOnlySpan_1<System_Internal.Byte>): boolean;
+    TryReadBytes(count: int, bytes: ReadOnlyMemory_1<System_Internal.Byte>): boolean;
 }
 
 
 export const PgReader: {
-    new(): PgReader;
 };
 
 
 export type PgReader = PgReader$instance;
 
 export interface PgResolverTypeInfo$instance extends PgTypeInfo {
+    readonly __tsonic_type_Npgsql_Internal_PgResolverTypeInfo: never;
+
     GetConverterResolver(): PgConverterResolver;
-    GetDefaultResolution(expectedPgTypeId: Nullable<PgTypeId>): PgConverterResolution;
-    GetResolution<T>(value: T, expectedPgTypeId: Nullable<PgTypeId>): Nullable<PgConverterResolution>;
+    GetDefaultResolution(expectedPgTypeId: Nullable_1<PgTypeId>): PgConverterResolution;
+    GetResolution<T>(value: T, expectedPgTypeId: Nullable_1<PgTypeId>): Nullable_1<PgConverterResolution>;
     GetResolution(field: Field): PgConverterResolution;
     GetResolution<T>(value: T): PgConverterResolution;
-    GetResolutionAsObject(value: unknown, expectedPgTypeId: Nullable<PgTypeId>): Nullable<PgConverterResolution>;
+    GetResolutionAsObject(value: unknown, expectedPgTypeId: Nullable_1<PgTypeId>): Nullable_1<PgConverterResolution>;
 }
 
 
 export const PgResolverTypeInfo: {
-    new(options: PgSerializerOptions, converterResolver: PgConverterResolver, pgTypeId: Nullable<PgTypeId>, unboxedType: Type): PgResolverTypeInfo;
+    new(options: PgSerializerOptions, converterResolver: PgConverterResolver, pgTypeId: Nullable_1<PgTypeId>, unboxedType: Type): PgResolverTypeInfo;
 };
 
 
 export type PgResolverTypeInfo = PgResolverTypeInfo$instance;
 
 export interface PgSerializerOptions$instance {
+    readonly __tsonic_type_Npgsql_Internal_PgSerializerOptions: never;
+
     ArrayNullabilityMode: ArrayNullabilityMode;
     DefaultNameTranslator: INpgsqlNameTranslator;
     EnableDateTimeInfinityConversions: boolean;
@@ -465,7 +496,6 @@ export interface PgSerializerOptions$instance {
 
 
 export const PgSerializerOptions: {
-    new(): PgSerializerOptions;
     IsWellKnownTextType(type: Type): boolean;
 };
 
@@ -473,25 +503,28 @@ export const PgSerializerOptions: {
 export type PgSerializerOptions = PgSerializerOptions$instance;
 
 export interface PgStreamingConverter_1$instance<T> extends PgConverter_1<T> {
+    readonly __tsonic_type_Npgsql_Internal_PgStreamingConverter_1: never;
+
     CanConvert(format: DataFormat, bufferRequirements: BufferRequirements): boolean;
 }
 
 
-export const PgStreamingConverter_1: {
-    new<T>(customDbNullPredicate: boolean): PgStreamingConverter_1<T>;
+export const PgStreamingConverter_1: (abstract new<T>(customDbNullPredicate: boolean) => PgStreamingConverter_1<T>) & {
 };
 
 
 export type PgStreamingConverter_1<T> = PgStreamingConverter_1$instance<T>;
 
 export interface PgTypeInfo$instance {
+    readonly __tsonic_type_Npgsql_Internal_PgTypeInfo: never;
+
     readonly Options: PgSerializerOptions;
-    readonly PgTypeId: Nullable<PgTypeId>;
-    PreferredFormat: Nullable<DataFormat>;
+    readonly PgTypeId: Nullable_1<PgTypeId>;
+    PreferredFormat: Nullable_1<DataFormat>;
     SupportsReading: boolean;
     SupportsWriting: boolean;
     readonly Type: Type;
-    GetBufferRequirements(converter: PgConverter, format: DataFormat): Nullable<BufferRequirements>;
+    GetBufferRequirements(converter: PgConverter, format: DataFormat): Nullable_1<BufferRequirements>;
     GetObjectResolution(value: unknown): PgConverterResolution;
     GetResolution<T>(value: T): PgConverterResolution;
 }
@@ -505,6 +538,8 @@ export const PgTypeInfo: {
 export type PgTypeInfo = PgTypeInfo$instance;
 
 export interface PgTypeInfoResolverFactory$instance {
+    readonly __tsonic_type_Npgsql_Internal_PgTypeInfoResolverFactory: never;
+
     CreateArrayResolver(): IPgTypeInfoResolver | undefined;
     CreateMultirangeArrayResolver(): IPgTypeInfoResolver | undefined;
     CreateMultirangeResolver(): IPgTypeInfoResolver | undefined;
@@ -514,17 +549,18 @@ export interface PgTypeInfoResolverFactory$instance {
 }
 
 
-export const PgTypeInfoResolverFactory: {
-    new(): PgTypeInfoResolverFactory;
+export const PgTypeInfoResolverFactory: (abstract new() => PgTypeInfoResolverFactory) & {
 };
 
 
 export type PgTypeInfoResolverFactory = PgTypeInfoResolverFactory$instance;
 
 export interface PgWriter$instance {
+    readonly __tsonic_type_Npgsql_Internal_PgWriter: never;
+
     readonly Current: ValueMetadata;
     BeginNestedWrite(bufferRequirement: Size, byteCount: int, state: unknown): NestedWriteScope;
-    BeginNestedWriteAsync(bufferRequirement: Size, byteCount: int, state: unknown, cancellationToken?: CancellationToken): ValueTask<NestedWriteScope>;
+    BeginNestedWriteAsync(bufferRequirement: Size, byteCount: int, state: unknown, cancellationToken?: CancellationToken): ValueTask_1<NestedWriteScope>;
     Flush(timeout?: TimeSpan): void;
     FlushAsync(cancellationToken?: CancellationToken): ValueTask;
     GetStream(allowMixedIO?: boolean): Stream;
@@ -532,10 +568,10 @@ export interface PgWriter$instance {
     ShouldFlush(byteCount: int): boolean;
     WriteAsOid(pgTypeId: PgTypeId): void;
     WriteByte(value: byte): void;
-    WriteBytes(buffer: ReadOnlySpan<System_Internal.Byte>): void;
-    WriteBytesAsync(buffer: ReadOnlyMemory<System_Internal.Byte>, cancellationToken?: CancellationToken): ValueTask;
-    WriteChars(data: ReadOnlySpan<System_Internal.Char>, encoding: Encoding): void;
-    WriteCharsAsync(data: ReadOnlyMemory<System_Internal.Char>, encoding: Encoding, cancellationToken?: CancellationToken): ValueTask;
+    WriteBytes(buffer: ReadOnlySpan_1<System_Internal.Byte>): void;
+    WriteBytesAsync(buffer: ReadOnlyMemory_1<System_Internal.Byte>, cancellationToken?: CancellationToken): ValueTask;
+    WriteChars(data: ReadOnlySpan_1<System_Internal.Char>, encoding: Encoding): void;
+    WriteCharsAsync(data: ReadOnlyMemory_1<System_Internal.Char>, encoding: Encoding, cancellationToken?: CancellationToken): ValueTask;
     WriteDouble(value: double): void;
     WriteFloat(value: float): void;
     WriteInt16(value: short): void;
@@ -548,21 +584,22 @@ export interface PgWriter$instance {
 
 
 export const PgWriter: {
-    new(): PgWriter;
 };
 
 
 export type PgWriter = PgWriter$instance;
 
 export interface TypeInfoMappingCollection$instance {
-    readonly Items: IReadOnlyList<TypeInfoMapping>;
+    readonly __tsonic_type_Npgsql_Internal_TypeInfoMappingCollection: never;
+
+    readonly Items: IReadOnlyList_1<TypeInfoMapping>;
     Add(mapping: TypeInfoMapping): void;
     AddArrayType<TElement>(elementDataTypeName: string): void;
     AddArrayType<TElement>(elementDataTypeName: string, suppressObjectMapping: boolean): void;
     AddArrayType<TElement>(elementMapping: TypeInfoMapping): void;
     AddArrayType<TElement>(elementMapping: TypeInfoMapping, suppressObjectMapping: boolean): void;
-    AddPolymorphicResolverArrayType(elementDataTypeName: string, elementToArrayConverterFactory: Func<PgSerializerOptions, Func<PgConverterResolution, PgConverter>>): void;
-    AddPolymorphicResolverArrayType(elementMapping: TypeInfoMapping, elementToArrayConverterFactory: Func<PgSerializerOptions, Func<PgConverterResolution, PgConverter>>): void;
+    AddPolymorphicResolverArrayType(elementDataTypeName: string, elementToArrayConverterFactory: Func_2<PgSerializerOptions, Func_2<PgConverterResolution, PgConverter>>): void;
+    AddPolymorphicResolverArrayType(elementMapping: TypeInfoMapping, elementToArrayConverterFactory: Func_2<PgSerializerOptions, Func_2<PgConverterResolution, PgConverter>>): void;
     AddRange(collection: TypeInfoMappingCollection): void;
     AddResolverArrayType<TElement>(elementDataTypeName: string): void;
     AddResolverArrayType<TElement>(elementDataTypeName: string, suppressObjectMapping: boolean): void;
@@ -574,21 +611,21 @@ export interface TypeInfoMappingCollection$instance {
     AddResolverStructArrayType<TElement extends unknown>(elementMapping: TypeInfoMapping, nullableElementMapping: TypeInfoMapping, suppressObjectMapping: boolean): void;
     AddResolverStructType<T extends unknown>(dataTypeName: string, createInfo: TypeInfoFactory, isDefault?: boolean): void;
     AddResolverStructType<T extends unknown>(dataTypeName: string, createInfo: TypeInfoFactory, matchRequirement: MatchRequirement): void;
-    AddResolverStructType<T extends unknown>(dataTypeName: string, createInfo: TypeInfoFactory, configure: Func<TypeInfoMapping, TypeInfoMapping>): void;
+    AddResolverStructType<T extends unknown>(dataTypeName: string, createInfo: TypeInfoFactory, configure: Func_2<TypeInfoMapping, TypeInfoMapping>): void;
     AddResolverType<T>(dataTypeName: string, createInfo: TypeInfoFactory, isDefault?: boolean): void;
     AddResolverType<T>(dataTypeName: string, createInfo: TypeInfoFactory, matchRequirement: MatchRequirement): void;
-    AddResolverType<T>(dataTypeName: string, createInfo: TypeInfoFactory, configure: Func<TypeInfoMapping, TypeInfoMapping>): void;
+    AddResolverType<T>(dataTypeName: string, createInfo: TypeInfoFactory, configure: Func_2<TypeInfoMapping, TypeInfoMapping>): void;
     AddStructArrayType<TElement extends unknown>(elementDataTypeName: string): void;
     AddStructArrayType<TElement extends unknown>(elementDataTypeName: string, suppressObjectMapping: boolean): void;
     AddStructArrayType<TElement extends unknown>(elementMapping: TypeInfoMapping, nullableElementMapping: TypeInfoMapping): void;
     AddStructArrayType<TElement extends unknown>(elementMapping: TypeInfoMapping, nullableElementMapping: TypeInfoMapping, suppressObjectMapping: boolean): void;
     AddStructType<T extends unknown>(dataTypeName: string, createInfo: TypeInfoFactory, isDefault?: boolean): void;
     AddStructType<T extends unknown>(dataTypeName: string, createInfo: TypeInfoFactory, matchRequirement: MatchRequirement): void;
-    AddStructType<T extends unknown>(dataTypeName: string, createInfo: TypeInfoFactory, configure: Func<TypeInfoMapping, TypeInfoMapping>): void;
+    AddStructType<T extends unknown>(dataTypeName: string, createInfo: TypeInfoFactory, configure: Func_2<TypeInfoMapping, TypeInfoMapping>): void;
     AddType<T>(dataTypeName: string, createInfo: TypeInfoFactory, isDefault?: boolean): void;
     AddType<T>(dataTypeName: string, createInfo: TypeInfoFactory, matchRequirement: MatchRequirement): void;
-    AddType<T>(dataTypeName: string, createInfo: TypeInfoFactory, configure: Func<TypeInfoMapping, TypeInfoMapping>): void;
-    Find(type: Type, dataTypeName: Nullable<DataTypeName>, options: PgSerializerOptions): PgTypeInfo | undefined;
+    AddType<T>(dataTypeName: string, createInfo: TypeInfoFactory, configure: Func_2<TypeInfoMapping, TypeInfoMapping>): void;
+    Find(type: Type, dataTypeName: Nullable_1<DataTypeName>, options: PgSerializerOptions): PgTypeInfo | undefined;
 }
 
 
@@ -596,7 +633,7 @@ export const TypeInfoMappingCollection: {
     new(capacity: int): TypeInfoMappingCollection;
     new(): TypeInfoMappingCollection;
     new(baseCollection: TypeInfoMappingCollection): TypeInfoMappingCollection;
-    new(items: IEnumerable<TypeInfoMapping>): TypeInfoMappingCollection;
+    new(items: IEnumerable_1<TypeInfoMapping>): TypeInfoMappingCollection;
     IsArrayLikeType(type: Type, elementType: Type): boolean;
 };
 
@@ -605,8 +642,8 @@ export type TypeInfoMappingCollection = TypeInfoMappingCollection$instance;
 
 export abstract class PgConverterFactory$instance {
     static CreateArrayMultirangeConverter<T>(rangeConverter: PgConverter_1<T>, options: PgSerializerOptions): PgConverter_1<T[]>;
-    static CreateListMultirangeConverter<T>(rangeConverter: PgConverter_1<T>, options: PgSerializerOptions): PgConverter_1<List<T>>;
-    static CreatePolymorphicArrayConverter<TBase>(arrayConverterFactory: Func<PgConverter_1<TBase>>, nullableArrayConverterFactory: Func<PgConverter_1<TBase>>, options: PgSerializerOptions): PgConverter_1<TBase>;
+    static CreateListMultirangeConverter<T>(rangeConverter: PgConverter_1<T>, options: PgSerializerOptions): PgConverter_1<List_1<T>>;
+    static CreatePolymorphicArrayConverter<TBase>(arrayConverterFactory: Func_1<PgConverter_1<TBase>>, nullableArrayConverterFactory: Func_1<PgConverter_1<TBase>>, options: PgSerializerOptions): PgConverter_1<TBase>;
     static CreateRangeConverter<T>(subTypeConverter: PgConverter_1<T>, options: PgSerializerOptions): PgConverter_1<NpgsqlRange_1<T>>;
 }
 
@@ -614,9 +651,9 @@ export abstract class PgConverterFactory$instance {
 export type PgConverterFactory = PgConverterFactory$instance;
 
 export abstract class TypeInfoMappingHelpers$instance {
-    static CreateInfo(mapping: TypeInfoMapping, options: PgSerializerOptions, converter: PgConverter, preferredFormat?: Nullable<DataFormat>, supportsWriting?: boolean): PgTypeInfo;
+    static CreateInfo(mapping: TypeInfoMapping, options: PgSerializerOptions, converter: PgConverter, preferredFormat?: Nullable_1<DataFormat>, supportsWriting?: boolean): PgTypeInfo;
     static CreateInfo(mapping: TypeInfoMapping, options: PgSerializerOptions, converter: PgConverter): PgTypeInfo;
-    static CreateInfo(mapping: TypeInfoMapping, options: PgSerializerOptions, resolver: PgConverterResolver, includeDataTypeName: boolean, preferredFormat?: Nullable<DataFormat>, supportsWriting?: boolean): PgResolverTypeInfo;
+    static CreateInfo(mapping: TypeInfoMapping, options: PgSerializerOptions, resolver: PgConverterResolver, includeDataTypeName: boolean, preferredFormat?: Nullable_1<DataFormat>, supportsWriting?: boolean): PgResolverTypeInfo;
     static CreateInfo(mapping: TypeInfoMapping, options: PgSerializerOptions, resolver: PgConverterResolver, includeDataTypeName: boolean): PgResolverTypeInfo;
 }
 

package/Npgsql.Internal.Postgres/internal/index.d.ts

@@ -6,10 +6,14 @@
 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 types from other namespaces
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, IEquatable, Int32, Object as ClrObject, String as ClrString, UInt32, ValueType } from "@tsonic/dotnet/System.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Boolean as ClrBoolean, IEquatable_1, Int32, Object as ClrObject, String as ClrString, UInt32, ValueType } from "@tsonic/dotnet/System/internal/index.js";
 
 export interface DataTypeName$instance {
+    readonly __tsonic_type_Npgsql_Internal_Postgres_DataTypeName: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly DisplayName: string;
     readonly IsArray: boolean;
     readonly IsUnqualified: boolean;
@@ -37,6 +41,8 @@ export const DataTypeName: {
 export type DataTypeName = DataTypeName$instance;
 
 export interface Field$instance {
+    readonly __tsonic_type_Npgsql_Internal_Postgres_Field: never;
+
     Name: string;
     PgTypeId: PgTypeId;
     TypeModifier: int;
@@ -51,6 +57,10 @@ export const Field: {
 export type Field = Field$instance;
 
 export interface Oid$instance {
+    readonly __tsonic_type_Npgsql_Internal_Postgres_Oid: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     Value: uint;
     Equals(other: Oid): boolean;
     Equals(obj: unknown): boolean;
@@ -68,6 +78,10 @@ export const Oid: {
 export type Oid = Oid$instance;
 
 export interface PgTypeId$instance {
+    readonly __tsonic_type_Npgsql_Internal_Postgres_PgTypeId: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly DataTypeName: DataTypeName;
     readonly IsDataTypeName: boolean;
     readonly IsOid: boolean;