@tsonic/efcore-npgsql 10.0.2 → 10.0.7

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

@@ -8,11 +8,15 @@ import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint12
 // Import types from other namespaces
 import * as Npgsql_Internal from "../../Npgsql/internal/index.js";
 import type { INpgsqlNameTranslator } from "../../Npgsql/internal/index.js";
-import type { CultureInfo } from "@tsonic/dotnet/System.Globalization.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System.js";
+import type { CultureInfo } from "@tsonic/dotnet/System.Globalization/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System/internal/index.js";
+
+export interface NpgsqlNullNameTranslator$instance extends Npgsql_Internal.INpgsqlNameTranslator$instance {
+    readonly __tsonic_type_Npgsql_NameTranslation_NpgsqlNullNameTranslator: never;
+
+    readonly __tsonic_iface_Npgsql_INpgsqlNameTranslator: never;
 
-export interface NpgsqlNullNameTranslator$instance {
     TranslateMemberName(clrName: string): string;
     TranslateTypeName(clrName: string): string;
 }
@@ -27,12 +31,14 @@ export interface __NpgsqlNullNameTranslator$views {
     As_INpgsqlNameTranslator(): Npgsql_Internal.INpgsqlNameTranslator$instance;
 }
 
-export interface NpgsqlNullNameTranslator$instance extends Npgsql_Internal.INpgsqlNameTranslator$instance {}
-
 export type NpgsqlNullNameTranslator = NpgsqlNullNameTranslator$instance & __NpgsqlNullNameTranslator$views;
 
 
-export interface NpgsqlSnakeCaseNameTranslator$instance {
+export interface NpgsqlSnakeCaseNameTranslator$instance extends Npgsql_Internal.INpgsqlNameTranslator$instance {
+    readonly __tsonic_type_Npgsql_NameTranslation_NpgsqlSnakeCaseNameTranslator: never;
+
+    readonly __tsonic_iface_Npgsql_INpgsqlNameTranslator: never;
+
     TranslateMemberName(clrName: string): string;
     TranslateTypeName(clrName: string): string;
 }
@@ -49,8 +55,6 @@ export interface __NpgsqlSnakeCaseNameTranslator$views {
     As_INpgsqlNameTranslator(): Npgsql_Internal.INpgsqlNameTranslator$instance;
 }
 
-export interface NpgsqlSnakeCaseNameTranslator$instance extends Npgsql_Internal.INpgsqlNameTranslator$instance {}
-
 export type NpgsqlSnakeCaseNameTranslator = NpgsqlSnakeCaseNameTranslator$instance & __NpgsqlSnakeCaseNameTranslator$views;
 
 

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

@@ -6,46 +6,51 @@
 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 type { IReadOnlyList } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, UInt32 } from "@tsonic/dotnet/System.js";
+import type { IReadOnlyList_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, UInt32 } from "@tsonic/dotnet/System/internal/index.js";
 
 export interface PostgresArrayType$instance extends PostgresType {
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresArrayType: never;
+
     readonly Element: PostgresType;
 }
 
 
-export const PostgresArrayType: {
-    new(ns: string, name: string, oid: uint, elementPostgresType: PostgresType): PostgresArrayType;
+export const PostgresArrayType: (abstract new(ns: string, name: string, oid: uint, elementPostgresType: PostgresType) => PostgresArrayType) & {
 };
 
 
 export type PostgresArrayType = PostgresArrayType$instance;
 
 export interface PostgresBaseType$instance extends PostgresType {
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresBaseType: never;
+
 }
 
 
-export const PostgresBaseType: {
-    new(ns: string, name: string, oid: uint): PostgresBaseType;
+export const PostgresBaseType: (abstract new(ns: string, name: string, oid: uint) => PostgresBaseType) & {
 };
 
 
 export type PostgresBaseType = PostgresBaseType$instance;
 
 export interface PostgresCompositeType$instance extends PostgresType {
-    readonly Fields: IReadOnlyList<PostgresCompositeType_Field>;
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresCompositeType: never;
+
+    readonly Fields: IReadOnlyList_1<PostgresCompositeType_Field>;
 }
 
 
 export const PostgresCompositeType: {
-    new(): PostgresCompositeType;
 };
 
 
 export type PostgresCompositeType = PostgresCompositeType$instance;
 
 export interface PostgresCompositeType_Field$instance {
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresCompositeType_Field: never;
+
     readonly Name: string;
     readonly Type: PostgresType;
     ToString(): string;
@@ -53,66 +58,71 @@ export interface PostgresCompositeType_Field$instance {
 
 
 export const PostgresCompositeType_Field: {
-    new(): PostgresCompositeType_Field;
 };
 
 
 export type PostgresCompositeType_Field = PostgresCompositeType_Field$instance;
 
 export interface PostgresDomainType$instance extends PostgresType {
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresDomainType: never;
+
     readonly BaseType: PostgresType;
     readonly NotNull: boolean;
 }
 
 
-export const PostgresDomainType: {
-    new(ns: string, name: string, oid: uint, baseType: PostgresType, notNull: boolean): PostgresDomainType;
+export const PostgresDomainType: (abstract new(ns: string, name: string, oid: uint, baseType: PostgresType, notNull: boolean) => PostgresDomainType) & {
 };
 
 
 export type PostgresDomainType = PostgresDomainType$instance;
 
 export interface PostgresEnumType$instance extends PostgresType {
-    readonly Labels: IReadOnlyList<System_Internal.String>;
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresEnumType: never;
+
+    readonly Labels: IReadOnlyList_1<System_Internal.String>;
 }
 
 
-export const PostgresEnumType: {
-    new(ns: string, name: string, oid: uint): PostgresEnumType;
+export const PostgresEnumType: (abstract new(ns: string, name: string, oid: uint) => PostgresEnumType) & {
 };
 
 
 export type PostgresEnumType = PostgresEnumType$instance;
 
 export interface PostgresMultirangeType$instance extends PostgresType {
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresMultirangeType: never;
+
     readonly Subrange: PostgresRangeType;
 }
 
 
-export const PostgresMultirangeType: {
-    new(ns: string, name: string, oid: uint, rangePostgresType: PostgresRangeType): PostgresMultirangeType;
+export const PostgresMultirangeType: (abstract new(ns: string, name: string, oid: uint, rangePostgresType: PostgresRangeType) => PostgresMultirangeType) & {
 };
 
 
 export type PostgresMultirangeType = PostgresMultirangeType$instance;
 
 export interface PostgresRangeType$instance extends PostgresType {
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresRangeType: never;
+
     get Multirange(): PostgresMultirangeType | undefined;
-    set Multirange(value: PostgresMultirangeType);
+    set Multirange(value: PostgresMultirangeType | undefined);
     readonly Subtype: PostgresType;
 }
 
 
-export const PostgresRangeType: {
-    new(ns: string, name: string, oid: uint, subtypePostgresType: PostgresType): PostgresRangeType;
+export const PostgresRangeType: (abstract new(ns: string, name: string, oid: uint, subtypePostgresType: PostgresType) => PostgresRangeType) & {
 };
 
 
 export type PostgresRangeType = PostgresRangeType$instance;
 
 export interface PostgresType$instance {
+    readonly __tsonic_type_Npgsql_PostgresTypes_PostgresType: never;
+
     get Array(): PostgresArrayType | undefined;
-    set Array(value: PostgresArrayType);
+    set Array(value: PostgresArrayType | undefined);
     readonly DisplayName: string;
     readonly FullName: string;
     readonly InternalName: string;
@@ -120,7 +130,7 @@ export interface PostgresType$instance {
     readonly Namespace: string;
     readonly OID: uint;
     get Range(): PostgresRangeType | undefined;
-    set Range(value: PostgresRangeType);
+    set Range(value: PostgresRangeType | undefined);
     ToString(): string;
 }
 
@@ -132,11 +142,12 @@ export const PostgresType: {
 export type PostgresType = PostgresType$instance;
 
 export interface UnknownBackendType$instance extends PostgresType {
+    readonly __tsonic_type_Npgsql_PostgresTypes_UnknownBackendType: never;
+
 }
 
 
 export const UnknownBackendType: {
-    new(): UnknownBackendType;
 };
 
 

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

@@ -10,13 +10,13 @@ import type { PgOutputReplicationMessage } from "../../Npgsql.Replication.PgOutp
 import type { PgOutputReplicationOptions, PgOutputReplicationSlot } from "../../Npgsql.Replication.PgOutput/internal/index.js";
 import type { TestDecodingData, TestDecodingOptions, TestDecodingReplicationSlot } from "../../Npgsql.Replication.TestDecoding/internal/index.js";
 import type { NpgsqlLogSequenceNumber } from "../../NpgsqlTypes/internal/index.js";
-import type { IAsyncEnumerable } from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { Stream } from "@tsonic/dotnet/System.IO.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Byte, DateTime, Enum, IAsyncDisposable, IComparable, IConvertible, IFormattable, Int32, ISpanFormattable, Nullable, Object as ClrObject, String as ClrString, TimeSpan, UInt32, ValueType, Version, Void } from "@tsonic/dotnet/System.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 { IAsyncEnumerable_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { Stream } from "@tsonic/dotnet/System.IO/internal/index.js";
+import type { Encoding } from "@tsonic/dotnet/System.Text/internal/index.js";
+import type { Task, Task_1, ValueTask } 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 { Boolean as ClrBoolean, Byte, DateTime, Enum, IAsyncDisposable, IComparable, IConvertible, IFormattable, Int32, ISpanFormattable, Nullable_1, Object as ClrObject, String as ClrString, TimeSpan, UInt32, ValueType, Version, Void } from "@tsonic/dotnet/System/internal/index.js";
 
 export enum LogicalSlotSnapshotInitMode {
     Export = 0,
@@ -26,6 +26,8 @@ export enum LogicalSlotSnapshotInitMode {
 
 
 export interface ReplicationSlotOptions$instance {
+    readonly __tsonic_type_Npgsql_Replication_ReplicationSlotOptions: never;
+
     readonly ConsistentPoint: NpgsqlLogSequenceNumber;
     readonly SlotName: string;
 }
@@ -40,6 +42,8 @@ export const ReplicationSlotOptions: {
 export type ReplicationSlotOptions = ReplicationSlotOptions$instance;
 
 export interface TimelineHistoryFile$instance {
+    readonly __tsonic_type_Npgsql_Replication_TimelineHistoryFile: never;
+
     readonly Content: byte[];
     readonly FileName: string;
 }
@@ -53,6 +57,10 @@ export const TimelineHistoryFile: {
 export type TimelineHistoryFile = TimelineHistoryFile$instance;
 
 export interface LogicalReplicationConnection$instance extends ReplicationConnection {
+    readonly __tsonic_type_Npgsql_Replication_LogicalReplicationConnection: never;
+
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+
 }
 
 
@@ -65,11 +73,15 @@ export const LogicalReplicationConnection: {
 export type LogicalReplicationConnection = LogicalReplicationConnection$instance;
 
 export interface PhysicalReplicationConnection$instance extends ReplicationConnection {
-    CreateReplicationSlot(slotName: string, isTemporary?: boolean, reserveWal?: boolean, cancellationToken?: CancellationToken): Task<PhysicalReplicationSlot>;
-    ReadReplicationSlot(slotName: string, cancellationToken?: CancellationToken): Task<PhysicalReplicationSlot | undefined>;
-    StartReplication(slot: PhysicalReplicationSlot, walLocation: NpgsqlLogSequenceNumber, cancellationToken: CancellationToken, timeline?: uint): IAsyncEnumerable<XLogDataMessage>;
-    StartReplication(walLocation: NpgsqlLogSequenceNumber, cancellationToken: CancellationToken, timeline?: uint): IAsyncEnumerable<XLogDataMessage>;
-    StartReplication(slot: PhysicalReplicationSlot, cancellationToken: CancellationToken): IAsyncEnumerable<XLogDataMessage>;
+    readonly __tsonic_type_Npgsql_Replication_PhysicalReplicationConnection: never;
+
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+
+    CreateReplicationSlot(slotName: string, isTemporary?: boolean, reserveWal?: boolean, cancellationToken?: CancellationToken): Task_1<PhysicalReplicationSlot>;
+    ReadReplicationSlot(slotName: string, cancellationToken?: CancellationToken): Task_1<PhysicalReplicationSlot | undefined>;
+    StartReplication(slot: PhysicalReplicationSlot, walLocation: NpgsqlLogSequenceNumber, cancellationToken: CancellationToken, timeline?: uint): IAsyncEnumerable_1<XLogDataMessage>;
+    StartReplication(walLocation: NpgsqlLogSequenceNumber, cancellationToken: CancellationToken, timeline?: uint): IAsyncEnumerable_1<XLogDataMessage>;
+    StartReplication(slot: PhysicalReplicationSlot, cancellationToken: CancellationToken): IAsyncEnumerable_1<XLogDataMessage>;
 }
 
 
@@ -82,19 +94,25 @@ export const PhysicalReplicationConnection: {
 export type PhysicalReplicationConnection = PhysicalReplicationConnection$instance;
 
 export interface PhysicalReplicationSlot$instance extends ReplicationSlot {
-    readonly RestartLsn: Nullable<NpgsqlLogSequenceNumber>;
-    readonly RestartTimeline: Nullable<System_Internal.UInt32>;
+    readonly __tsonic_type_Npgsql_Replication_PhysicalReplicationSlot: never;
+
+    readonly RestartLsn: Nullable_1<NpgsqlLogSequenceNumber>;
+    readonly RestartTimeline: Nullable_1<System_Internal.UInt32>;
 }
 
 
 export const PhysicalReplicationSlot: {
-    new(slotName: string, restartLsn: Nullable<NpgsqlLogSequenceNumber>, restartTimeline: Nullable<System_Internal.UInt32>): PhysicalReplicationSlot;
+    new(slotName: string, restartLsn: Nullable_1<NpgsqlLogSequenceNumber>, restartTimeline: Nullable_1<System_Internal.UInt32>): PhysicalReplicationSlot;
 };
 
 
 export type PhysicalReplicationSlot = PhysicalReplicationSlot$instance;
 
 export interface ReplicationConnection$instance {
+    readonly __tsonic_type_Npgsql_Replication_ReplicationConnection: never;
+
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+
     CommandTimeout: TimeSpan;
     ConnectionString: string;
     readonly Encoding: Encoding;
@@ -108,12 +126,12 @@ export interface ReplicationConnection$instance {
     WalReceiverTimeout: TimeSpan;
     DisposeAsync(): ValueTask;
     DropReplicationSlot(slotName: string, wait?: boolean, cancellationToken?: CancellationToken): Task;
-    IdentifySystem(cancellationToken?: CancellationToken): Task<ReplicationSystemIdentification>;
+    IdentifySystem(cancellationToken?: CancellationToken): Task_1<ReplicationSystemIdentification>;
     Open(cancellationToken?: CancellationToken): Task;
     SendStatusUpdate(cancellationToken?: CancellationToken): Task;
     SetReplicationStatus(lastAppliedAndFlushedLsn: NpgsqlLogSequenceNumber): void;
-    Show(parameterName: string, cancellationToken?: CancellationToken): Task<System_Internal.String>;
-    TimelineHistory(tli: uint, cancellationToken?: CancellationToken): Task<TimelineHistoryFile>;
+    Show(parameterName: string, cancellationToken?: CancellationToken): Task_1<System_Internal.String>;
+    TimelineHistory(tli: uint, cancellationToken?: CancellationToken): Task_1<TimelineHistoryFile>;
 }
 
 
@@ -124,20 +142,23 @@ export const ReplicationConnection: {
 export type ReplicationConnection = ReplicationConnection$instance;
 
 export interface ReplicationMessage$instance {
+    readonly __tsonic_type_Npgsql_Replication_ReplicationMessage: never;
+
     ServerClock: DateTime;
     WalEnd: NpgsqlLogSequenceNumber;
     WalStart: NpgsqlLogSequenceNumber;
 }
 
 
-export const ReplicationMessage: {
-    new(): ReplicationMessage;
+export const ReplicationMessage: (abstract new() => ReplicationMessage) & {
 };
 
 
 export type ReplicationMessage = ReplicationMessage$instance;
 
 export interface ReplicationSlot$instance {
+    readonly __tsonic_type_Npgsql_Replication_ReplicationSlot: never;
+
     readonly Name: string;
 }
 
@@ -149,6 +170,8 @@ export const ReplicationSlot: {
 export type ReplicationSlot = ReplicationSlot$instance;
 
 export interface ReplicationSystemIdentification$instance {
+    readonly __tsonic_type_Npgsql_Replication_ReplicationSystemIdentification: never;
+
     readonly DbName: string | undefined;
     readonly SystemId: string;
     readonly Timeline: uint;
@@ -157,13 +180,14 @@ export interface ReplicationSystemIdentification$instance {
 
 
 export const ReplicationSystemIdentification: {
-    new(): ReplicationSystemIdentification;
 };
 
 
 export type ReplicationSystemIdentification = ReplicationSystemIdentification$instance;
 
 export interface XLogDataMessage$instance extends ReplicationMessage {
+    readonly __tsonic_type_Npgsql_Replication_XLogDataMessage: never;
+
     Data: Stream;
 }
 
@@ -176,16 +200,16 @@ export const XLogDataMessage: {
 export type XLogDataMessage = XLogDataMessage$instance;
 
 export abstract class PgOutputConnectionExtensions$instance {
-    static CreatePgOutputReplicationSlot(connection: LogicalReplicationConnection, slotName: string, temporarySlot?: boolean, slotSnapshotInitMode?: Nullable<LogicalSlotSnapshotInitMode>, twoPhase?: boolean, cancellationToken?: CancellationToken): Task<PgOutputReplicationSlot>;
-    static StartReplication(connection: LogicalReplicationConnection, slot: PgOutputReplicationSlot, options: PgOutputReplicationOptions, cancellationToken: CancellationToken, walLocation?: Nullable<NpgsqlLogSequenceNumber>): IAsyncEnumerable<PgOutputReplicationMessage>;
+    static CreatePgOutputReplicationSlot(connection: LogicalReplicationConnection, slotName: string, temporarySlot?: boolean, slotSnapshotInitMode?: Nullable_1<LogicalSlotSnapshotInitMode>, twoPhase?: boolean, cancellationToken?: CancellationToken): Task_1<PgOutputReplicationSlot>;
+    static StartReplication(connection: LogicalReplicationConnection, slot: PgOutputReplicationSlot, options: PgOutputReplicationOptions, cancellationToken: CancellationToken, walLocation?: Nullable_1<NpgsqlLogSequenceNumber>): IAsyncEnumerable_1<PgOutputReplicationMessage>;
 }
 
 
 export type PgOutputConnectionExtensions = PgOutputConnectionExtensions$instance;
 
 export abstract class TestDecodingConnectionExtensions$instance {
-    static CreateTestDecodingReplicationSlot(connection: LogicalReplicationConnection, slotName: string, temporarySlot?: boolean, slotSnapshotInitMode?: Nullable<LogicalSlotSnapshotInitMode>, twoPhase?: boolean, cancellationToken?: CancellationToken): Task<TestDecodingReplicationSlot>;
-    static StartReplication(connection: LogicalReplicationConnection, slot: TestDecodingReplicationSlot, cancellationToken: CancellationToken, options?: TestDecodingOptions, walLocation?: Nullable<NpgsqlLogSequenceNumber>): IAsyncEnumerable<TestDecodingData>;
+    static CreateTestDecodingReplicationSlot(connection: LogicalReplicationConnection, slotName: string, temporarySlot?: boolean, slotSnapshotInitMode?: Nullable_1<LogicalSlotSnapshotInitMode>, twoPhase?: boolean, cancellationToken?: CancellationToken): Task_1<TestDecodingReplicationSlot>;
+    static StartReplication(connection: LogicalReplicationConnection, slot: TestDecodingReplicationSlot, cancellationToken: CancellationToken, options?: TestDecodingOptions, walLocation?: Nullable_1<NpgsqlLogSequenceNumber>): IAsyncEnumerable_1<TestDecodingData>;
 }
 
 

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

@@ -9,29 +9,30 @@ import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint12
 import * as Npgsql_Replication_Internal from "../../Npgsql.Replication/internal/index.js";
 import type { LogicalReplicationConnection, LogicalSlotSnapshotInitMode, ReplicationSlot, ReplicationSlotOptions, XLogDataMessage } from "../../Npgsql.Replication/internal/index.js";
 import type { NpgsqlLogSequenceNumber } from "../../NpgsqlTypes/internal/index.js";
-import type { IAsyncEnumerable, IEnumerable, KeyValuePair } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Nullable, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System.js";
-import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
-import type { Task } from "@tsonic/dotnet/System.Threading.Tasks.js";
+import type { IAsyncEnumerable_1, IEnumerable_1, KeyValuePair_2 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { Task_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 { Boolean as ClrBoolean, Nullable_1, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System/internal/index.js";
 
 export interface LogicalReplicationSlot$instance extends ReplicationSlot {
+    readonly __tsonic_type_Npgsql_Replication_Internal_LogicalReplicationSlot: never;
+
     readonly ConsistentPoint: NpgsqlLogSequenceNumber;
     readonly OutputPlugin: string;
     readonly SnapshotName: string | undefined;
 }
 
 
-export const LogicalReplicationSlot: {
-    new(outputPlugin: string, replicationSlotOptions: ReplicationSlotOptions): LogicalReplicationSlot;
+export const LogicalReplicationSlot: (abstract new(outputPlugin: string, replicationSlotOptions: ReplicationSlotOptions) => LogicalReplicationSlot) & {
 };
 
 
 export type LogicalReplicationSlot = LogicalReplicationSlot$instance;
 
 export abstract class LogicalReplicationConnectionExtensions$instance {
-    static CreateLogicalReplicationSlot(connection: LogicalReplicationConnection, slotName: string, outputPlugin: string, isTemporary?: boolean, slotSnapshotInitMode?: Nullable<LogicalSlotSnapshotInitMode>, twoPhase?: boolean, cancellationToken?: CancellationToken): Task<ReplicationSlotOptions>;
-    static StartLogicalReplication(connection: LogicalReplicationConnection, slot: LogicalReplicationSlot, cancellationToken: CancellationToken, walLocation?: Nullable<NpgsqlLogSequenceNumber>, options?: IEnumerable<KeyValuePair<System_Internal.String, System_Internal.String>>, bypassingStream?: boolean): IAsyncEnumerable<XLogDataMessage>;
+    static CreateLogicalReplicationSlot(connection: LogicalReplicationConnection, slotName: string, outputPlugin: string, isTemporary?: boolean, slotSnapshotInitMode?: Nullable_1<LogicalSlotSnapshotInitMode>, twoPhase?: boolean, cancellationToken?: CancellationToken): Task_1<ReplicationSlotOptions>;
+    static StartLogicalReplication(connection: LogicalReplicationConnection, slot: LogicalReplicationSlot, cancellationToken: CancellationToken, walLocation?: Nullable_1<NpgsqlLogSequenceNumber>, options?: IEnumerable_1<KeyValuePair_2<System_Internal.String, System_Internal.String>>, bypassingStream?: boolean): IAsyncEnumerable_1<XLogDataMessage>;
 }
 
 

package/Npgsql.Replication.PgOutput/internal/index.d.ts

@@ -11,13 +11,13 @@ import * as Npgsql_Replication_Internal_Internal from "../../Npgsql.Replication.
 import type { LogicalReplicationSlot } from "../../Npgsql.Replication.Internal/internal/index.js";
 import type { ReplicationSlotOptions } from "../../Npgsql.Replication/internal/index.js";
 import type { NpgsqlLogSequenceNumber } from "../../NpgsqlTypes/internal/index.js";
-import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { IAsyncEnumerable, IAsyncEnumerator, IEnumerable, List } from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { Stream, TextReader } from "@tsonic/dotnet/System.IO.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Byte, Enum, IComparable, IConvertible, IEquatable, IFormattable, Int32, ISpanFormattable, Nullable, Object as ClrObject, String as ClrString, Type, UInt16, UInt64 } from "@tsonic/dotnet/System.js";
-import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
-import type { ValueTask } from "@tsonic/dotnet/System.Threading.Tasks.js";
+import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { IAsyncEnumerable_1, IAsyncEnumerator_1, IEnumerable_1, List_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { Stream, TextReader } from "@tsonic/dotnet/System.IO/internal/index.js";
+import type { 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 { Boolean as ClrBoolean, Byte, Enum, IComparable, IConvertible, IEquatable_1, IFormattable, Int32, ISpanFormattable, Nullable_1, Object as ClrObject, String as ClrString, Type, UInt16, UInt64 } from "@tsonic/dotnet/System/internal/index.js";
 
 export enum PgOutputProtocolVersion {
     V1 = 1,
@@ -43,12 +43,16 @@ export enum TupleDataKind {
 
 
 export interface PgOutputReplicationOptions$instance {
-    readonly Binary: Nullable<System_Internal.Boolean>;
-    readonly Messages: Nullable<System_Internal.Boolean>;
+    readonly __tsonic_type_Npgsql_Replication_PgOutput_PgOutputReplicationOptions: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
+    readonly Binary: Nullable_1<System_Internal.Boolean>;
+    readonly Messages: Nullable_1<System_Internal.Boolean>;
     readonly ProtocolVersion: PgOutputProtocolVersion;
-    readonly PublicationNames: List<System_Internal.String>;
-    readonly StreamingMode: Nullable<PgOutputStreamingMode>;
-    readonly TwoPhase: Nullable<System_Internal.Boolean>;
+    readonly PublicationNames: List_1<System_Internal.String>;
+    readonly StreamingMode: Nullable_1<PgOutputStreamingMode>;
+    readonly TwoPhase: Nullable_1<System_Internal.Boolean>;
     Equals(other: PgOutputReplicationOptions): boolean;
     Equals(obj: unknown): boolean;
     GetHashCode(): int;
@@ -56,48 +60,54 @@ export interface PgOutputReplicationOptions$instance {
 
 
 export const PgOutputReplicationOptions: {
-    new(publicationName: string, protocolVersion: ulong, binary: Nullable<System_Internal.Boolean>, streaming: Nullable<System_Internal.Boolean>, messages: Nullable<System_Internal.Boolean>, twoPhase: Nullable<System_Internal.Boolean>): PgOutputReplicationOptions;
-    new(publicationName: string, protocolVersion: PgOutputProtocolVersion, binary: Nullable<System_Internal.Boolean>, streamingMode: Nullable<PgOutputStreamingMode>, messages: Nullable<System_Internal.Boolean>, twoPhase: Nullable<System_Internal.Boolean>): PgOutputReplicationOptions;
-    new(publicationNames: IEnumerable<System_Internal.String>, protocolVersion: ulong, binary: Nullable<System_Internal.Boolean>, streaming: Nullable<System_Internal.Boolean>, messages: Nullable<System_Internal.Boolean>, twoPhase: Nullable<System_Internal.Boolean>): PgOutputReplicationOptions;
-    new(publicationNames: IEnumerable<System_Internal.String>, protocolVersion: PgOutputProtocolVersion, binary: Nullable<System_Internal.Boolean>, streamingMode: Nullable<PgOutputStreamingMode>, messages: Nullable<System_Internal.Boolean>, twoPhase: Nullable<System_Internal.Boolean>): PgOutputReplicationOptions;
+    new(publicationName: string, protocolVersion: ulong, binary: Nullable_1<System_Internal.Boolean>, streaming: Nullable_1<System_Internal.Boolean>, messages: Nullable_1<System_Internal.Boolean>, twoPhase: Nullable_1<System_Internal.Boolean>): PgOutputReplicationOptions;
+    new(publicationName: string, protocolVersion: PgOutputProtocolVersion, binary: Nullable_1<System_Internal.Boolean>, streamingMode: Nullable_1<PgOutputStreamingMode>, messages: Nullable_1<System_Internal.Boolean>, twoPhase: Nullable_1<System_Internal.Boolean>): PgOutputReplicationOptions;
+    new(publicationNames: IEnumerable_1<System_Internal.String>, protocolVersion: ulong, binary: Nullable_1<System_Internal.Boolean>, streaming: Nullable_1<System_Internal.Boolean>, messages: Nullable_1<System_Internal.Boolean>, twoPhase: Nullable_1<System_Internal.Boolean>): PgOutputReplicationOptions;
+    new(publicationNames: IEnumerable_1<System_Internal.String>, protocolVersion: PgOutputProtocolVersion, binary: Nullable_1<System_Internal.Boolean>, streamingMode: Nullable_1<PgOutputStreamingMode>, messages: Nullable_1<System_Internal.Boolean>, twoPhase: Nullable_1<System_Internal.Boolean>): PgOutputReplicationOptions;
 };
 
 
 export type PgOutputReplicationOptions = PgOutputReplicationOptions$instance;
 
 export interface PgOutputReplicationSlot$instance extends LogicalReplicationSlot {
+    readonly __tsonic_type_Npgsql_Replication_PgOutput_PgOutputReplicationSlot: never;
+
 }
 
 
 export const PgOutputReplicationSlot: {
     new(slotName: string): PgOutputReplicationSlot;
     new(options: ReplicationSlotOptions): PgOutputReplicationSlot;
-    new(slot: PgOutputReplicationSlot): PgOutputReplicationSlot;
 };
 
 
 export type PgOutputReplicationSlot = PgOutputReplicationSlot$instance;
 
 export interface ReplicationTuple$instance {
+    readonly __tsonic_type_Npgsql_Replication_PgOutput_ReplicationTuple: never;
+
+    readonly __tsonic_iface_System_Collections_Generic_IAsyncEnumerable_1: never;
+
     NumColumns: ushort;
-    GetAsyncEnumerator(cancellationToken?: CancellationToken): IAsyncEnumerator<ReplicationValue>;
+    GetAsyncEnumerator(cancellationToken?: CancellationToken): IAsyncEnumerator_1<ReplicationValue>;
 }
 
 
 export const ReplicationTuple: {
-    new(): ReplicationTuple;
 };
 
 
 export type ReplicationTuple = ReplicationTuple$instance;
 
 export interface ReplicationValue$instance {
+    readonly __tsonic_type_Npgsql_Replication_PgOutput_ReplicationValue: never;
+
     readonly IsDBNull: boolean;
     readonly IsUnchangedToastedValue: boolean;
     Kind: TupleDataKind;
     Length: int;
-    Get<T>(cancellationToken?: CancellationToken): ValueTask<T>;
-    Get(cancellationToken?: CancellationToken): ValueTask<unknown>;
+    Get<T>(cancellationToken?: CancellationToken): ValueTask_1<T>;
+    Get(cancellationToken?: CancellationToken): ValueTask_1<unknown>;
     GetDataTypeName(): string;
     GetFieldName(): string;
     GetFieldType(): Type;
@@ -108,7 +118,6 @@ export interface ReplicationValue$instance {
 
 
 export const ReplicationValue: {
-    new(): ReplicationValue;
 };