@tsonic/efcore-npgsql 0.1.1

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

@@ -0,0 +1,591 @@
+// Generated by tsbindgen - Architecture
+// Namespace: Npgsql.Internal
+// Assembly: Npgsql
+
+// Primitive type aliases from @tsonic/core
+import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';
+
+// Import support types from @tsonic/core
+import type { ptr } from "@tsonic/core/types.js";
+
+// Import types from other namespaces
+import type { DataTypeName, Field, PgTypeId } from "../../Npgsql.Internal.Postgres/internal/index.js";
+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 { 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";
+
+export enum DataFormat {
+    binary = 0,
+    text = 1
+}
+
+
+export enum MatchRequirement {
+    all = 0,
+    single = 1,
+    dataTypeName = 2
+}
+
+
+export enum SizeKind {
+    unknown_ = 0,
+    exact = 1,
+    upperBound = 2
+}
+
+
+export type TypeInfoFactory = (options: PgSerializerOptions, mapping: TypeInfoMapping, requiresDataTypeName: boolean) => PgTypeInfo;
+
+
+export interface IDbTypeResolver$instance {
+    getDataTypeName(dbType: DbType, type_: Type): string | undefined;
+    getDbType(dataTypeName: DataTypeName): Nullable<DbType>;
+}
+
+
+export type IDbTypeResolver = IDbTypeResolver$instance;
+
+export interface INpgsqlDatabaseInfoFactory$instance {
+    load(conn: NpgsqlConnector, timeout: NpgsqlTimeout, async_: boolean): Task<NpgsqlDatabaseInfo | undefined>;
+}
+
+
+export type INpgsqlDatabaseInfoFactory = INpgsqlDatabaseInfoFactory$instance;
+
+export interface IPgTypeInfoResolver$instance {
+    getTypeInfo(type_: Type, dataTypeName: Nullable<DataTypeName>, options: PgSerializerOptions): PgTypeInfo | undefined;
+}
+
+
+export type IPgTypeInfoResolver = IPgTypeInfoResolver$instance;
+
+export interface BufferRequirements$instance {
+    readonly read: Size;
+    readonly write: Size;
+    combine(read: Size, write: Size): BufferRequirements;
+    combine(other: BufferRequirements): BufferRequirements;
+    combine(byteCount: int): BufferRequirements;
+    equals(other: BufferRequirements): boolean;
+    equals(obj: unknown): boolean;
+    getHashCode(): int;
+}
+
+
+export const BufferRequirements: {
+    new(): BufferRequirements;
+    readonly none: BufferRequirements;
+    readonly value: BufferRequirements;
+    create(read: Size, write: Size): BufferRequirements;
+    create(value: Size): BufferRequirements;
+    createFixedSize(byteCount: int): BufferRequirements;
+};
+
+
+export type BufferRequirements = BufferRequirements$instance;
+
+export interface NestedReadScope$instance {
+    dispose(): void;
+    disposeAsync(): ValueTask;
+}
+
+
+export const NestedReadScope: {
+    new(): NestedReadScope;
+};
+
+
+export type NestedReadScope = NestedReadScope$instance;
+
+export interface NestedWriteScope$instance {
+    dispose(): void;
+}
+
+
+export const NestedWriteScope: {
+    new(): NestedWriteScope;
+};
+
+
+export type NestedWriteScope = NestedWriteScope$instance;
+
+export interface PgConverterResolution$instance {
+    readonly converter: PgConverter;
+    readonly pgTypeId: PgTypeId;
+    getConverter<T>(): PgConverter_1<T>;
+}
+
+
+export const PgConverterResolution: {
+    new(converter: PgConverter, pgTypeId: PgTypeId): PgConverterResolution;
+};
+
+
+export type PgConverterResolution = PgConverterResolution$instance;
+
+export interface Size$instance {
+    readonly kind: SizeKind;
+    readonly value: int;
+    combine(other: Size): Size;
+    equals(other: Size): boolean;
+    equals(obj: unknown): boolean;
+    getHashCode(): int;
+    toString(): string;
+    tryCombine(other: Size, result: Size): boolean;
+}
+
+
+export const Size: {
+    new(): Size;
+    readonly unknown_: Size;
+    readonly zero: Size;
+    create(byteCount: int): Size;
+    createUpperBound(byteCount: int): Size;
+};
+
+
+export type Size = Size$instance;
+
+export interface SizeContext$instance {
+    bufferRequirement: Size;
+    readonly format: DataFormat;
+}
+
+
+export const SizeContext: {
+    new(format: DataFormat, bufferRequirement: Size): SizeContext;
+};
+
+
+export type SizeContext = SizeContext$instance;
+
+export interface TypeInfoMapping$instance {
+    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>);
+    dataTypeNameEquals(dataTypeName: string): boolean;
+    typeEquals(type_: Type): boolean;
+}
+
+
+export const TypeInfoMapping: {
+    new(type_: Type, dataTypeName: string, factory: TypeInfoFactory): TypeInfoMapping;
+};
+
+
+export type TypeInfoMapping = TypeInfoMapping$instance;
+
+export interface ValueMetadata$instance {
+    bufferRequirement: Size;
+    format: DataFormat;
+    size: Size;
+    get writeState(): unknown | undefined;
+    set writeState(value: unknown);
+}
+
+
+export const ValueMetadata: {
+    new(): ValueMetadata;
+};
+
+
+export type ValueMetadata = ValueMetadata$instance;
+
+export interface DbTypeResolverFactory$instance {
+    createDbTypeResolver(databaseInfo: NpgsqlDatabaseInfo): IDbTypeResolver;
+}
+
+
+export const DbTypeResolverFactory: {
+};
+
+
+export type DbTypeResolverFactory = DbTypeResolverFactory$instance;
+
+export interface DynamicTypeInfoResolver$instance {
+    getTypeInfo(type_: Type, dataTypeName: Nullable<DataTypeName>, options: PgSerializerOptions): PgTypeInfo | undefined;
+}
+
+
+export const DynamicTypeInfoResolver: {
+};
+
+
+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 databaseInfo: NpgsqlDatabaseInfo;
+    readonly settings: NpgsqlConnectionStringBuilder;
+    readonly textEncoding: Encoding;
+    createBatch(): NpgsqlBatch;
+    createCommand(cmdText?: string): NpgsqlCommand;
+}
+
+
+export const NpgsqlConnector: {
+    new(): NpgsqlConnector;
+};
+
+
+export type NpgsqlConnector = NpgsqlConnector$instance;
+
+export interface NpgsqlDatabaseInfo$instance {
+    readonly hasIntegerDateTimes: boolean;
+    readonly host: string;
+    readonly name: string;
+    readonly port: int;
+    readonly serverVersion: string;
+    readonly supportsAdvisoryLocks: boolean;
+    readonly supportsCloseAll: boolean;
+    readonly supportsDiscard: boolean;
+    readonly supportsDiscardSequences: boolean;
+    readonly supportsDiscardTemp: boolean;
+    readonly supportsEnumTypes: boolean;
+    readonly supportsMultirangeTypes: boolean;
+    readonly supportsRangeTypes: boolean;
+    readonly supportsTransactions: boolean;
+    readonly supportsUnlisten: boolean;
+    readonly version: Version;
+    getPostgresType(oid: uint): PostgresType;
+    getPostgresType(pgName: string): PostgresType;
+    tryGetPostgresTypeByName(pgName: string, pgType: PostgresType): boolean;
+}
+
+
+export const NpgsqlDatabaseInfo: {
+    registerFactory(factory: INpgsqlDatabaseInfoFactory): void;
+};
+
+
+export type NpgsqlDatabaseInfo = NpgsqlDatabaseInfo$instance;
+
+export interface PgBufferedConverter_1$instance<T> extends 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>;
+    write(writer: PgWriter, value: T): void;
+    writeAsync(writer: PgWriter, value: T, cancellationToken?: CancellationToken): ValueTask;
+}
+
+
+export const PgBufferedConverter_1: {
+};
+
+
+export type PgBufferedConverter_1<T> = PgBufferedConverter_1$instance<T>;
+
+export interface PgConverter$instance {
+    readonly isDbNullable: boolean;
+    canConvert(format: DataFormat, bufferRequirements: BufferRequirements): boolean;
+}
+
+
+export const PgConverter: {
+};
+
+
+export type PgConverter = PgConverter$instance;
+
+export interface PgConverter_1$instance<T> extends PgConverter {
+    getSize(context: SizeContext, value: T, writeState: unknown): Size;
+    isDbNull(value: T, writeState: unknown): boolean;
+    read(reader: PgReader): T;
+    readAsync(reader: PgReader, cancellationToken?: CancellationToken): ValueTask<T>;
+    write(writer: PgWriter, value: T): void;
+    writeAsync(writer: PgWriter, value: T, cancellationToken?: CancellationToken): ValueTask;
+}
+
+
+export const PgConverter_1: {
+};
+
+
+export type PgConverter_1<T> = PgConverter_1$instance<T>;
+
+export interface PgConverterResolver$instance {
+    get_(field: Field): PgConverterResolution;
+    getDefault(pgTypeId: Nullable<PgTypeId>): PgConverterResolution;
+}
+
+
+export const PgConverterResolver: {
+};
+
+
+export type PgConverterResolver = PgConverterResolver$instance;
+
+export interface PgConverterResolver_1$instance<T> extends PgConverterResolver {
+    get_(value: T, expectedPgTypeId: Nullable<PgTypeId>): Nullable<PgConverterResolution>;
+    get_(field: Field): PgConverterResolution;
+}
+
+
+export const PgConverterResolver_1: {
+};
+
+
+export type PgConverterResolver_1<T> = PgConverterResolver_1$instance<T>;
+
+export interface PgReader$instance {
+    readonly current: ValueMetadata;
+    readonly currentRemaining: int;
+    readonly isResumed: boolean;
+    beginNestedRead(size: int, bufferRequirement: Size): NestedReadScope;
+    beginNestedReadAsync(size: int, bufferRequirement: Size, cancellationToken?: CancellationToken): ValueTask<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;
+    getTextReader(encoding: Encoding): TextReader;
+    getTextReaderAsync(encoding: Encoding, cancellationToken: CancellationToken): ValueTask<TextReader>;
+    read(destination: Span<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>>;
+    readDouble(): double;
+    readFloat(): float;
+    readInt16(): short;
+    readInt32(): int;
+    readInt64(): long;
+    readNullTerminatedString(encoding: Encoding): string;
+    readNullTerminatedStringAsync(encoding: Encoding, cancellationToken?: CancellationToken): ValueTask<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;
+}
+
+
+export const PgReader: {
+    new(): PgReader;
+};
+
+
+export type PgReader = PgReader$instance;
+
+export interface PgResolverTypeInfo$instance extends PgTypeInfo {
+    getConverterResolver(): PgConverterResolver;
+    getDefaultResolution(expectedPgTypeId: Nullable<PgTypeId>): PgConverterResolution;
+    getResolution<T>(value: T, expectedPgTypeId: Nullable<PgTypeId>): Nullable<PgConverterResolution>;
+    getResolution(field: Field): PgConverterResolution;
+    getResolution<T>(value: T): PgConverterResolution;
+    getResolutionAsObject(value: unknown, expectedPgTypeId: Nullable<PgTypeId>): Nullable<PgConverterResolution>;
+}
+
+
+export const PgResolverTypeInfo: {
+    new(options: PgSerializerOptions, converterResolver: PgConverterResolver, pgTypeId: Nullable<PgTypeId>, unboxedType: Type): PgResolverTypeInfo;
+};
+
+
+export type PgResolverTypeInfo = PgResolverTypeInfo$instance;
+
+export interface PgSerializerOptions$instance {
+    arrayNullabilityMode: ArrayNullabilityMode;
+    defaultNameTranslator: INpgsqlNameTranslator;
+    enableDateTimeInfinityConversions: boolean;
+    textEncoding: Encoding;
+    readonly timeZone: string;
+    readonly typeInfoResolver: IPgTypeInfoResolver;
+    getArrayElementTypeId(arrayTypeId: PgTypeId): PgTypeId;
+    getArrayTypeId(elementTypeId: PgTypeId): PgTypeId;
+    getDataTypeName(pgTypeId: PgTypeId): DataTypeName;
+    getDefaultTypeInfo(type_: Type): PgTypeInfo | undefined;
+    getDefaultTypeInfo(pgTypeId: PgTypeId): PgTypeInfo | undefined;
+    getMultirangeElementTypeId(multirangeTypeId: PgTypeId): PgTypeId;
+    getMultirangeTypeId(rangeTypeId: PgTypeId): PgTypeId;
+    getRangeSubtypeTypeId(rangeTypeId: PgTypeId): PgTypeId;
+    getRangeTypeId(subtypeTypeId: PgTypeId): PgTypeId;
+    getTypeInfo(type_: Type, pgTypeId: PgTypeId): PgTypeInfo | undefined;
+    tryGetDataTypeName(pgTypeId: PgTypeId, dataTypeName: DataTypeName): boolean;
+}
+
+
+export const PgSerializerOptions: {
+    new(): PgSerializerOptions;
+    isWellKnownTextType(type_: Type): boolean;
+};
+
+
+export type PgSerializerOptions = PgSerializerOptions$instance;
+
+export interface PgStreamingConverter_1$instance<T> extends PgConverter_1<T> {
+    canConvert(format: DataFormat, bufferRequirements: BufferRequirements): boolean;
+}
+
+
+export const PgStreamingConverter_1: {
+};
+
+
+export type PgStreamingConverter_1<T> = PgStreamingConverter_1$instance<T>;
+
+export interface PgTypeInfo$instance {
+    readonly options: PgSerializerOptions;
+    readonly pgTypeId: Nullable<PgTypeId>;
+    preferredFormat: Nullable<DataFormat>;
+    supportsReading: boolean;
+    supportsWriting: boolean;
+    readonly type_: Type;
+    getBufferRequirements(converter: PgConverter, format: DataFormat): Nullable<BufferRequirements>;
+    getObjectResolution(value: unknown): PgConverterResolution;
+    getResolution<T>(value: T): PgConverterResolution;
+}
+
+
+export const PgTypeInfo: {
+    new(options: PgSerializerOptions, converter: PgConverter, pgTypeId: PgTypeId, unboxedType: Type): PgTypeInfo;
+};
+
+
+export type PgTypeInfo = PgTypeInfo$instance;
+
+export interface PgTypeInfoResolverFactory$instance {
+    createArrayResolver(): IPgTypeInfoResolver | undefined;
+    createMultirangeArrayResolver(): IPgTypeInfoResolver | undefined;
+    createMultirangeResolver(): IPgTypeInfoResolver | undefined;
+    createRangeArrayResolver(): IPgTypeInfoResolver | undefined;
+    createRangeResolver(): IPgTypeInfoResolver | undefined;
+    createResolver(): IPgTypeInfoResolver;
+}
+
+
+export const PgTypeInfoResolverFactory: {
+};
+
+
+export type PgTypeInfoResolverFactory = PgTypeInfoResolverFactory$instance;
+
+export interface PgWriter$instance {
+    readonly current: ValueMetadata;
+    beginNestedWrite(bufferRequirement: Size, byteCount: int, state: unknown): NestedWriteScope;
+    beginNestedWriteAsync(bufferRequirement: Size, byteCount: int, state: unknown, cancellationToken?: CancellationToken): ValueTask<NestedWriteScope>;
+    flush(timeout?: TimeSpan): void;
+    flushAsync(cancellationToken?: CancellationToken): ValueTask;
+    getStream(allowMixedIO?: boolean): Stream;
+    shouldFlush(bufferRequirement: Size): boolean;
+    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;
+    writeDouble(value: double): void;
+    writeFloat(value: float): void;
+    writeInt16(value: short): void;
+    writeInt32(value: int): void;
+    writeInt64(value: long): void;
+    writeUInt16(value: ushort): void;
+    writeUInt32(value: uint): void;
+    writeUInt64(value: ulong): void;
+}
+
+
+export const PgWriter: {
+    new(): PgWriter;
+};
+
+
+export type PgWriter = PgWriter$instance;
+
+export interface TypeInfoMappingCollection$instance {
+    readonly items: IReadOnlyList<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;
+    addRange(collection: TypeInfoMappingCollection): void;
+    addResolverArrayType<TElement>(elementDataTypeName: string): void;
+    addResolverArrayType<TElement>(elementDataTypeName: string, suppressObjectMapping: boolean): void;
+    addResolverArrayType<TElement>(elementMapping: TypeInfoMapping): void;
+    addResolverArrayType<TElement>(elementMapping: TypeInfoMapping, suppressObjectMapping: boolean): void;
+    addResolverStructArrayType<TElement extends unknown>(elementDataTypeName: string): void;
+    addResolverStructArrayType<TElement extends unknown>(elementDataTypeName: string, suppressObjectMapping: boolean): void;
+    addResolverStructArrayType<TElement extends unknown>(elementMapping: TypeInfoMapping, nullableElementMapping: TypeInfoMapping): void;
+    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;
+    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;
+    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;
+    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;
+}
+
+
+export const TypeInfoMappingCollection: {
+    new(capacity: int): TypeInfoMappingCollection;
+    new(): TypeInfoMappingCollection;
+    new(baseCollection: TypeInfoMappingCollection): TypeInfoMappingCollection;
+    new(items: IEnumerable<TypeInfoMapping>): TypeInfoMappingCollection;
+    isArrayLikeType(type_: Type, elementType: Type): boolean;
+};
+
+
+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 createRangeConverter<T>(subTypeConverter: PgConverter_1<T>, options: PgSerializerOptions): PgConverter_1<NpgsqlRange_1<T>>;
+}
+
+
+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): 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): PgResolverTypeInfo;
+}
+
+
+export type TypeInfoMappingHelpers = TypeInfoMappingHelpers$instance;
+