@tsonic/efcore-npgsql 10.0.2 → 10.0.7

package/Npgsql.EntityFrameworkCore.PostgreSQL.Metadata/internal/index.d.ts

@@ -6,11 +6,11 @@
 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 { IEnumerable, IReadOnlyList, List } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Enum, IComparable, IConvertible, IFormattable, Int32, ISpanFormattable, Nullable, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System.js";
-import type { Annotatable, IReadOnlyAnnotatable } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import type { IConventionAnnotatable, IMutableAnnotatable } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
+import type { IEnumerable_1, IReadOnlyList_1, List_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, Enum, IComparable, IConvertible, IFormattable, Int32, ISpanFormattable, Nullable_1, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System/internal/index.js";
+import type { Annotatable, IReadOnlyAnnotatable } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import type { IConventionAnnotatable, IMutableAnnotatable } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
 
 export enum NpgsqlValueGenerationStrategy {
     None = 0,
@@ -36,11 +36,13 @@ export enum SortOrder {
 
 
 export interface CockroachDbInterleaveInParent$instance {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_CockroachDbInterleaveInParent: never;
+
     readonly Annotatable: Annotatable;
-    InterleavePrefix: List<System_Internal.String>;
+    InterleavePrefix: List_1<System_Internal.String>;
     ParentTableName: string;
     get ParentTableSchema(): string | undefined;
-    set ParentTableSchema(value: string);
+    set ParentTableSchema(value: string | undefined);
 }
 
 
@@ -52,88 +54,93 @@ export const CockroachDbInterleaveInParent: {
 export type CockroachDbInterleaveInParent = CockroachDbInterleaveInParent$instance;
 
 export interface PostgresCollation$instance {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_PostgresCollation: never;
+
     readonly Annotatable: Annotatable;
-    IsDeterministic: Nullable<System_Internal.Boolean>;
+    IsDeterministic: Nullable_1<System_Internal.Boolean>;
     LcCollate: string;
     LcCtype: string;
     readonly Name: string;
     get Provider(): string | undefined;
-    set Provider(value: string);
+    set Provider(value: string | undefined);
     readonly Schema: string | undefined;
 }
 
 
 export const PostgresCollation: {
-    new(): PostgresCollation;
     FindCollation(annotatable: IReadOnlyAnnotatable, schema: string, name: string): PostgresCollation | undefined;
-    GetCollations(annotatable: IReadOnlyAnnotatable): IEnumerable<PostgresCollation>;
-    GetOrAddCollation(annotatable: IMutableAnnotatable, schema: string, name: string, lcCollate: string, lcCtype: string, provider?: string, deterministic?: Nullable<System_Internal.Boolean>): PostgresCollation;
+    GetCollations(annotatable: IReadOnlyAnnotatable): IEnumerable_1<PostgresCollation>;
+    GetOrAddCollation(annotatable: IMutableAnnotatable, schema: string, name: string, lcCollate: string, lcCtype: string, provider?: string, deterministic?: Nullable_1<System_Internal.Boolean>): PostgresCollation;
 };
 
 
 export type PostgresCollation = PostgresCollation$instance;
 
 export interface PostgresEnum$instance {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_PostgresEnum: never;
+
     readonly Annotatable: Annotatable;
-    Labels: IReadOnlyList<System_Internal.String>;
+    Labels: IReadOnlyList_1<System_Internal.String>;
     readonly Name: string;
     readonly Schema: string | undefined;
 }
 
 
 export const PostgresEnum: {
-    new(): PostgresEnum;
     FindPostgresEnum(annotatable: IReadOnlyAnnotatable, schema: string, name: string): PostgresEnum | undefined;
     GetOrAddPostgresEnum(annotatable: IConventionAnnotatable, schema: string, name: string, labels: string[]): PostgresEnum;
     GetOrAddPostgresEnum(annotatable: IMutableAnnotatable, schema: string, name: string, labels: string[]): PostgresEnum;
     GetOrAddPostgresEnum(annotatable: IMutableAnnotatable, name: string, labels: string[]): PostgresEnum;
-    GetPostgresEnums(annotatable: IReadOnlyAnnotatable): IEnumerable<PostgresEnum>;
+    GetPostgresEnums(annotatable: IReadOnlyAnnotatable): IEnumerable_1<PostgresEnum>;
 };
 
 
 export type PostgresEnum = PostgresEnum$instance;
 
 export interface PostgresExtension$instance {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_PostgresExtension: never;
+
     readonly Annotatable: Annotatable;
     readonly Name: string;
     readonly Schema: string | undefined;
-    Version: string;
+    get Version(): string | undefined;
+    set Version(value: string | undefined);
 }
 
 
 export const PostgresExtension: {
-    new(): PostgresExtension;
     FindPostgresExtension(annotatable: IReadOnlyAnnotatable, schema: string, name: string): PostgresExtension | undefined;
     GetOrAddPostgresExtension(annotatable: IConventionAnnotatable, schema: string, name: string, version: string): PostgresExtension;
     GetOrAddPostgresExtension(annotatable: IMutableAnnotatable, schema: string, name: string, version: string): PostgresExtension;
     GetOrAddPostgresExtension(annotatable: IMutableAnnotatable, name: string, version: string): PostgresExtension;
-    GetPostgresExtensions(annotatable: IReadOnlyAnnotatable): IEnumerable<PostgresExtension>;
+    GetPostgresExtensions(annotatable: IReadOnlyAnnotatable): IEnumerable_1<PostgresExtension>;
 };
 
 
 export type PostgresExtension = PostgresExtension$instance;
 
 export interface PostgresRange$instance {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_PostgresRange: never;
+
     readonly Annotatable: Annotatable;
     get CanonicalFunction(): string | undefined;
-    set CanonicalFunction(value: string);
+    set CanonicalFunction(value: string | undefined);
     get Collation(): string | undefined;
-    set Collation(value: string);
+    set Collation(value: string | undefined);
     readonly Name: string;
     readonly Schema: string | undefined;
     Subtype: string;
     get SubtypeDiff(): string | undefined;
-    set SubtypeDiff(value: string);
+    set SubtypeDiff(value: string | undefined);
     get SubtypeOpClass(): string | undefined;
-    set SubtypeOpClass(value: string);
+    set SubtypeOpClass(value: string | undefined);
 }
 
 
 export const PostgresRange: {
-    new(): PostgresRange;
     FindPostgresRange(annotatable: IReadOnlyAnnotatable, schema: string, name: string): PostgresRange | undefined;
     GetOrAddPostgresRange(annotatable: IMutableAnnotatable, schema: string, name: string, subtype: string, canonicalFunction?: string, subtypeOpClass?: string, collation?: string, subtypeDiff?: string): PostgresRange;
-    GetPostgresRanges(annotatable: IReadOnlyAnnotatable): IEnumerable<PostgresRange>;
+    GetPostgresRanges(annotatable: IReadOnlyAnnotatable): IEnumerable_1<PostgresRange>;
 };
 
 
@@ -141,7 +148,7 @@ export type PostgresRange = PostgresRange$instance;
 
 export abstract class NpgsqlValueGenerationStrategyExtensions$instance {
     static IsIdentity(strategy: NpgsqlValueGenerationStrategy): boolean;
-    static IsIdentity(strategy: Nullable<NpgsqlValueGenerationStrategy>): boolean;
+    static IsIdentity(strategy: Nullable_1<NpgsqlValueGenerationStrategy>): boolean;
 }
 
 

package/Npgsql.EntityFrameworkCore.PostgreSQL.Metadata.Conventions/internal/index.d.ts

@@ -11,19 +11,23 @@ import type { ptr } from "@tsonic/core/types.js";
 // Import types from other namespaces
 import type { EnumDefinition, INpgsqlSingletonOptions } from "../../Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal/internal/index.js";
 import type { NpgsqlTypeMappingSource } from "../../Npgsql.EntityFrameworkCore.PostgreSQL.Storage.Internal/internal/index.js";
-import type { Dictionary, IReadOnlyList } 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, Version, Void } from "@tsonic/dotnet/System.js";
-import type { ModelBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
-import type { IConventionModelBuilder, IConventionPropertyBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Builders.js";
-import * as Microsoft_EntityFrameworkCore_Metadata_Conventions_Infrastructure_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure.js";
-import type { IProviderConventionSetBuilder, ProviderConventionSetBuilderDependencies, RelationalConventionSetBuilder, RelationalConventionSetBuilderDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure.js";
-import * as Microsoft_EntityFrameworkCore_Metadata_Conventions_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions.js";
-import type { ConventionSet, IConvention, IConventionContext, IEntityTypeAnnotationChangedConvention, IEntityTypeBaseTypeChangedConvention, IEntityTypePrimaryKeyChangedConvention, IForeignKeyAddedConvention, IForeignKeyOwnershipChangedConvention, IForeignKeyPropertiesChangedConvention, IForeignKeyRemovedConvention, IModelFinalizedConvention, IModelFinalizingConvention, IModelInitializedConvention, IPropertyAnnotationChangedConvention, RelationalRuntimeModelConvention, RelationalValueGenerationConvention, SharedTableConvention, StoreGenerationConvention } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions.js";
-import type { IConventionAnnotation, IConventionProperty, IEntityType, IIndex, IModel, IProperty, IReadOnlyIndex, IReadOnlyProperty, RuntimeEntityType, RuntimeIndex, RuntimeModel, RuntimeProperty, StoreObjectIdentifier, ValueGenerated } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
-import type { IRelationalTypeMappingSource, RelationalTypeMapping } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage.js";
+import type { Dictionary_2, 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, Nullable_1, Object as ClrObject, String as ClrString, Version, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { IConventionModelBuilder, IConventionPropertyBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Builders/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Metadata_Conventions_Infrastructure_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure/internal/index.js";
+import type { IProviderConventionSetBuilder, ProviderConventionSetBuilderDependencies, RelationalConventionSetBuilder, RelationalConventionSetBuilderDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions.Infrastructure/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Metadata_Conventions_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions/internal/index.js";
+import type { ConventionSet, IConvention, IConventionContext_1, IEntityTypeAnnotationChangedConvention, IEntityTypeBaseTypeChangedConvention, IEntityTypePrimaryKeyChangedConvention, IForeignKeyAddedConvention, IForeignKeyOwnershipChangedConvention, IForeignKeyPropertiesChangedConvention, IForeignKeyRemovedConvention, IModelFinalizedConvention, IModelFinalizingConvention, IModelInitializedConvention, IPropertyAnnotationChangedConvention, RelationalRuntimeModelConvention, RelationalValueGenerationConvention, SharedTableConvention, StoreGenerationConvention } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions/internal/index.js";
+import type { IConventionAnnotation, IConventionProperty, IEntityType, IIndex, IModel, IProperty, IReadOnlyIndex, IReadOnlyProperty, RuntimeEntityType, RuntimeIndex, RuntimeModel, RuntimeProperty, StoreObjectIdentifier, ValueGenerated } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { IRelationalTypeMappingSource, RelationalTypeMapping } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage/internal/index.js";
+import type { ModelBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore/internal/index.js";
 
 export interface NpgsqlConventionSetBuilder$instance extends RelationalConventionSetBuilder {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Conventions_NpgsqlConventionSetBuilder: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_Infrastructure_IProviderConventionSetBuilder: never;
+
     CreateConventionSet(): ConventionSet;
 }
 
@@ -37,34 +41,36 @@ export const NpgsqlConventionSetBuilder: {
 
 export type NpgsqlConventionSetBuilder = NpgsqlConventionSetBuilder$instance;
 
-export abstract class NpgsqlPostgresModelFinalizingConvention$protected {
-    protected DiscoverPostgresExtensions(property: IConventionProperty, typeMapping: RelationalTypeMapping, modelBuilder: IConventionModelBuilder): void;
-    protected ProcessRowVersionProperty(property: IConventionProperty, typeMapping: RelationalTypeMapping): void;
-    protected SetupEnums(modelBuilder: IConventionModelBuilder): void;
-}
+export interface NpgsqlPostgresModelFinalizingConvention$instance {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Conventions_NpgsqlPostgresModelFinalizingConvention: never;
 
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
 
-export interface NpgsqlPostgresModelFinalizingConvention$instance extends NpgsqlPostgresModelFinalizingConvention$protected {
-    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext<IConventionModelBuilder>): void;
+    DiscoverPostgresExtensions(property: IConventionProperty, typeMapping: RelationalTypeMapping, modelBuilder: IConventionModelBuilder): void;
+    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
+    ProcessRowVersionProperty(property: IConventionProperty, typeMapping: RelationalTypeMapping): void;
+    SetupEnums(modelBuilder: IConventionModelBuilder): void;
 }
 
 
 export const NpgsqlPostgresModelFinalizingConvention: {
-    new(typeMappingSource: NpgsqlTypeMappingSource, enumDefinitions: IReadOnlyList<EnumDefinition>): NpgsqlPostgresModelFinalizingConvention;
+    new(typeMappingSource: NpgsqlTypeMappingSource, enumDefinitions: IReadOnlyList_1<EnumDefinition>): NpgsqlPostgresModelFinalizingConvention;
 };
 
 
 export type NpgsqlPostgresModelFinalizingConvention = NpgsqlPostgresModelFinalizingConvention$instance;
 
-export abstract class NpgsqlRuntimeModelConvention$protected {
-    protected ProcessEntityTypeAnnotations(annotations: Dictionary<System_Internal.String, unknown>, entityType: IEntityType, runtimeEntityType: RuntimeEntityType, runtime: boolean): void;
-    protected ProcessIndexAnnotations(annotations: Dictionary<System_Internal.String, unknown>, index: IIndex, runtimeIndex: RuntimeIndex, runtime: boolean): void;
-    protected ProcessModelAnnotations(annotations: Dictionary<System_Internal.String, unknown>, model: IModel, runtimeModel: RuntimeModel, runtime: boolean): void;
-    protected ProcessPropertyAnnotations(annotations: Dictionary<System_Internal.String, unknown>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
-}
+export interface NpgsqlRuntimeModelConvention$instance extends RelationalRuntimeModelConvention {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Conventions_NpgsqlRuntimeModelConvention: never;
 
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizedConvention: never;
 
-export interface NpgsqlRuntimeModelConvention$instance extends NpgsqlRuntimeModelConvention$protected, RelationalRuntimeModelConvention {
+    ProcessEntityTypeAnnotations(annotations: Dictionary_2<System_Internal.String, unknown>, entityType: IEntityType, runtimeEntityType: RuntimeEntityType, runtime: boolean): void;
+    ProcessIndexAnnotations(annotations: Dictionary_2<System_Internal.String, unknown>, index: IIndex, runtimeIndex: RuntimeIndex, runtime: boolean): void;
+    ProcessModelAnnotations(annotations: Dictionary_2<System_Internal.String, unknown>, model: IModel, runtimeModel: RuntimeModel, runtime: boolean): void;
+    ProcessPropertyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
 }
 
 
@@ -75,16 +81,17 @@ export const NpgsqlRuntimeModelConvention: {
 
 export type NpgsqlRuntimeModelConvention = NpgsqlRuntimeModelConvention$instance;
 
-export abstract class NpgsqlSharedTableConvention$protected {
-    protected readonly CheckConstraintsUniqueAcrossTables: boolean;
-    protected readonly ForeignKeysUniqueAcrossTables: boolean;
-    protected readonly IndexesUniqueAcrossTables: boolean;
-    protected readonly KeysUniqueAcrossTables: boolean;
-    protected AreCompatible(index: IReadOnlyIndex, duplicateIndex: IReadOnlyIndex, storeObject: StoreObjectIdentifier): boolean;
-}
+export interface NpgsqlSharedTableConvention$instance extends SharedTableConvention {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Conventions_NpgsqlSharedTableConvention: never;
 
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
 
-export interface NpgsqlSharedTableConvention$instance extends NpgsqlSharedTableConvention$protected, SharedTableConvention {
+    readonly CheckConstraintsUniqueAcrossTables: boolean;
+    readonly ForeignKeysUniqueAcrossTables: boolean;
+    readonly IndexesUniqueAcrossTables: boolean;
+    readonly KeysUniqueAcrossTables: boolean;
+    AreCompatible(index: IReadOnlyIndex, duplicateIndex: IReadOnlyIndex, storeObject: StoreObjectIdentifier): boolean;
 }
 
 
@@ -95,13 +102,15 @@ export const NpgsqlSharedTableConvention: {
 
 export type NpgsqlSharedTableConvention = NpgsqlSharedTableConvention$instance;
 
-export abstract class NpgsqlStoreGenerationConvention$protected {
-    protected Validate(property: IConventionProperty, storeObject: StoreObjectIdentifier): void;
-}
+export interface NpgsqlStoreGenerationConvention$instance extends StoreGenerationConvention {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Conventions_NpgsqlStoreGenerationConvention: never;
 
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAnnotationChangedConvention: never;
 
-export interface NpgsqlStoreGenerationConvention$instance extends NpgsqlStoreGenerationConvention$protected, StoreGenerationConvention {
-    ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation, oldAnnotation: IConventionAnnotation, context: IConventionContext<IConventionAnnotation>): void;
+    ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation, oldAnnotation: IConventionAnnotation, context: IConventionContext_1<IConventionAnnotation>): void;
+    Validate(property: IConventionProperty, storeObject: StoreObjectIdentifier): void;
 }
 
 
@@ -112,33 +121,43 @@ export const NpgsqlStoreGenerationConvention: {
 
 export type NpgsqlStoreGenerationConvention = NpgsqlStoreGenerationConvention$instance;
 
-export abstract class NpgsqlValueGenerationConvention$protected {
-    protected GetValueGenerated(property: IConventionProperty): Nullable<ValueGenerated>;
-}
-
-
-export interface NpgsqlValueGenerationConvention$instance extends NpgsqlValueGenerationConvention$protected, RelationalValueGenerationConvention {
-    ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation, oldAnnotation: IConventionAnnotation, context: IConventionContext<IConventionAnnotation>): void;
+export interface NpgsqlValueGenerationConvention$instance extends RelationalValueGenerationConvention {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Conventions_NpgsqlValueGenerationConvention: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeAnnotationChangedConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypeBaseTypeChangedConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IEntityTypePrimaryKeyChangedConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyAddedConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyOwnershipChangedConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyPropertiesChangedConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IForeignKeyRemovedConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IPropertyAnnotationChangedConvention: never;
+
+    GetValueGenerated(property: IConventionProperty): Nullable_1<ValueGenerated>;
+    ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation, oldAnnotation: IConventionAnnotation, context: IConventionContext_1<IConventionAnnotation>): void;
 }
 
 
 export const NpgsqlValueGenerationConvention: {
     new(dependencies: ProviderConventionSetBuilderDependencies, relationalDependencies: RelationalConventionSetBuilderDependencies): NpgsqlValueGenerationConvention;
-    GetValueGenerated(property: IReadOnlyProperty, storeObject: StoreObjectIdentifier): Nullable<ValueGenerated>;
+    GetValueGenerated(property: IReadOnlyProperty, storeObject: StoreObjectIdentifier): Nullable_1<ValueGenerated>;
 };
 
 
 export type NpgsqlValueGenerationConvention = NpgsqlValueGenerationConvention$instance;
 
-export abstract class NpgsqlValueGenerationStrategyConvention$protected {
-    protected readonly Dependencies: ProviderConventionSetBuilderDependencies;
-    protected readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
-}
+export interface NpgsqlValueGenerationStrategyConvention$instance {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Conventions_NpgsqlValueGenerationStrategyConvention: never;
 
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelInitializedConvention: never;
 
-export interface NpgsqlValueGenerationStrategyConvention$instance extends NpgsqlValueGenerationStrategyConvention$protected {
-    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext<IConventionModelBuilder>): void;
-    ProcessModelInitialized(modelBuilder: IConventionModelBuilder, context: IConventionContext<IConventionModelBuilder>): void;
+    readonly Dependencies: ProviderConventionSetBuilderDependencies;
+    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
+    ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
+    ProcessModelInitialized(modelBuilder: IConventionModelBuilder, context: IConventionContext_1<IConventionModelBuilder>): void;
 }
 
 

package/Npgsql.EntityFrameworkCore.PostgreSQL.Metadata.Internal/internal/index.d.ts

@@ -6,20 +6,24 @@
 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 { IEnumerable } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, IEquatable, Int32, Int64, Nullable, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System.js";
-import type { IAnnotation, IReadOnlyAnnotatable } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import * as Microsoft_EntityFrameworkCore_Metadata_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
-import type { IColumn, IRelationalAnnotationProvider, IRelationalModel, ITable, ITableIndex, RelationalAnnotationProvider, RelationalAnnotationProviderDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
+import type { IEnumerable_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, IEquatable_1, Int32, Int64, Nullable_1, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System/internal/index.js";
+import type { IAnnotation, IReadOnlyAnnotatable } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Metadata_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { IColumn, IRelationalAnnotationProvider, IRelationalModel, ITable, ITableIndex, RelationalAnnotationProvider, RelationalAnnotationProviderDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
 
 export interface IdentitySequenceOptionsData$instance {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Internal_IdentitySequenceOptionsData: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     IncrementBy: long;
     IsCyclic: boolean;
-    MaxValue: Nullable<System_Internal.Int64>;
-    MinValue: Nullable<System_Internal.Int64>;
+    MaxValue: Nullable_1<System_Internal.Int64>;
+    MinValue: Nullable_1<System_Internal.Int64>;
     NumbersToCache: long;
-    StartValue: Nullable<System_Internal.Int64>;
+    StartValue: Nullable_1<System_Internal.Int64>;
     Equals(other: IdentitySequenceOptionsData): boolean;
     Equals(obj: unknown): boolean;
     GetHashCode(): int;
@@ -38,10 +42,14 @@ export const IdentitySequenceOptionsData: {
 export type IdentitySequenceOptionsData = IdentitySequenceOptionsData$instance;
 
 export interface NpgsqlAnnotationProvider$instance extends RelationalAnnotationProvider {
-    For(table: ITable, designTime: boolean): IEnumerable<IAnnotation>;
-    For(column: IColumn, designTime: boolean): IEnumerable<IAnnotation>;
-    For(index: ITableIndex, designTime: boolean): IEnumerable<IAnnotation>;
-    For(model: IRelationalModel, designTime: boolean): IEnumerable<IAnnotation>;
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Metadata_Internal_NpgsqlAnnotationProvider: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IRelationalAnnotationProvider: never;
+
+    For(table: ITable, designTime: boolean): IEnumerable_1<IAnnotation>;
+    For(column: IColumn, designTime: boolean): IEnumerable_1<IAnnotation>;
+    For(index: ITableIndex, designTime: boolean): IEnumerable_1<IAnnotation>;
+    For(model: IRelationalModel, designTime: boolean): IEnumerable_1<IAnnotation>;
 }
 
 

package/Npgsql.EntityFrameworkCore.PostgreSQL.Migrations/internal/index.d.ts

@@ -10,58 +10,58 @@ import * as System_Internal from "@tsonic/dotnet/System.js";
 import type { INpgsqlSingletonOptions } from "../../Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal/internal/index.js";
 import type { PostgresCollation, PostgresEnum, PostgresExtension, PostgresRange } from "../../Npgsql.EntityFrameworkCore.PostgreSQL.Metadata/internal/index.js";
 import type { NpgsqlCreateDatabaseOperation, NpgsqlDropDatabaseOperation } from "../../Npgsql.EntityFrameworkCore.PostgreSQL.Migrations.Operations/internal/index.js";
-import type { IReadOnlyList } from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System.js";
-import type { IColumn, IModel } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
-import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.js";
-import type { IMigrationsSqlGenerator, MigrationCommand, MigrationCommandListBuilder, MigrationsSqlGenerationOptions, MigrationsSqlGenerator, MigrationsSqlGeneratorDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.js";
-import type { AddColumnOperation, AlterColumnOperation, AlterDatabaseOperation, AlterTableOperation, ColumnOperation, CreateIndexOperation, CreateSequenceOperation, CreateTableOperation, DropColumnOperation, DropIndexOperation, EnsureSchemaOperation, InsertDataOperation, MigrationOperation, RenameColumnOperation, RenameIndexOperation, RenameSequenceOperation, RenameTableOperation, RestartSequenceOperation, SequenceOperation } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.Operations.js";
+import type { IReadOnlyList_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { IColumn, IModel } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { AddColumnOperation, AlterColumnOperation, AlterDatabaseOperation, AlterTableOperation, ColumnOperation, CreateIndexOperation, CreateSequenceOperation, CreateTableOperation, DropColumnOperation, DropIndexOperation, EnsureSchemaOperation, InsertDataOperation, MigrationOperation, RenameColumnOperation, RenameIndexOperation, RenameSequenceOperation, RenameTableOperation, RestartSequenceOperation, SequenceOperation } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.Operations/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations/internal/index.js";
+import type { IMigrationsSqlGenerator, MigrationCommand, MigrationCommandListBuilder, MigrationsSqlGenerationOptions, MigrationsSqlGenerator, MigrationsSqlGeneratorDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations/internal/index.js";
 
-export abstract class NpgsqlMigrationsSqlGenerator$protected {
-    protected ApplyTsVectorColumnSql(column: ColumnOperation, model: IModel, name: string, schema: string, table: string): void;
-    protected ColumnDefinition(schema: string, table: string, name: string, operation: ColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected ComputedColumnDefinition(schema: string, table: string, name: string, operation: ColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected DefaultValue(defaultValue: unknown, defaultValueSql: string, columnType: string, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: MigrationOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AlterTableOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AlterColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RenameIndexOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RenameSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RestartSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RenameTableOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: EnsureSchemaOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: NpgsqlCreateDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RenameColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: CreateSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: CreateTableOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: DropColumnOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: AddColumnOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: CreateIndexOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: DropIndexOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: InsertDataOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected GenerateAddEnumLabel(enumType: PostgresEnum, addedLabel: string, beforeLabel: string, afterLabel: string, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateCollationStatements(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateCreateCollation(collation: PostgresCollation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateCreateEnum(enumType: PostgresEnum, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateCreateExtension(extension: PostgresExtension, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateCreateRange(rangeType: PostgresRange, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateDropCollation(collation: PostgresCollation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateDropEnum(enumType: PostgresEnum, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateDropRange(rangeType: PostgresRange, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateEnumStatements(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected GenerateRangeStatements(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected IdentityDefinition(operation: ColumnOperation, builder: MigrationCommandListBuilder): void;
-    protected IndexOptions(operation: MigrationOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected RecreateIndexes(column: IColumn, currentOperation: MigrationOperation, builder: MigrationCommandListBuilder): void;
-    protected SequenceOptions(schema: string, name: string, operation: SequenceOperation, model: IModel, builder: MigrationCommandListBuilder, forAlter: boolean): void;
-}
+export interface NpgsqlMigrationsSqlGenerator$instance extends MigrationsSqlGenerator {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Migrations_NpgsqlMigrationsSqlGenerator: never;
 
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Migrations_IMigrationsSqlGenerator: never;
 
-export interface NpgsqlMigrationsSqlGenerator$instance extends NpgsqlMigrationsSqlGenerator$protected, MigrationsSqlGenerator {
-    Generate(operations: IReadOnlyList<MigrationOperation>, model?: IModel, options?: MigrationsSqlGenerationOptions): IReadOnlyList<MigrationCommand>;
+    ApplyTsVectorColumnSql(column: ColumnOperation, model: IModel, name: string, schema: string, table: string): void;
+    ColumnDefinition(schema: string, table: string, name: string, operation: ColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    ComputedColumnDefinition(schema: string, table: string, name: string, operation: ColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    DefaultValue(defaultValue: unknown, defaultValueSql: string, columnType: string, builder: MigrationCommandListBuilder): void;
+    Generate(operations: IReadOnlyList_1<MigrationOperation>, model?: IModel, options?: MigrationsSqlGenerationOptions): IReadOnlyList_1<MigrationCommand>;
+    Generate(operation: MigrationOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: CreateTableOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: AlterTableOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: DropColumnOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: AddColumnOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: AlterColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: RenameIndexOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: RenameSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: RestartSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: RenameTableOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: CreateIndexOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: EnsureSchemaOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: NpgsqlCreateDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
     Generate(operation: NpgsqlDropDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: DropIndexOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: RenameColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: InsertDataOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: CreateSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateAddEnumLabel(enumType: PostgresEnum, addedLabel: string, beforeLabel: string, afterLabel: string, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateCollationStatements(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateCreateCollation(collation: PostgresCollation, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateCreateEnum(enumType: PostgresEnum, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateCreateExtension(extension: PostgresExtension, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateCreateRange(rangeType: PostgresRange, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateDropCollation(collation: PostgresCollation, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateDropEnum(enumType: PostgresEnum, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateDropRange(rangeType: PostgresRange, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateEnumStatements(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    GenerateRangeStatements(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    IdentityDefinition(operation: ColumnOperation, builder: MigrationCommandListBuilder): void;
+    IndexOptions(operation: MigrationOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    RecreateIndexes(column: IColumn, currentOperation: MigrationOperation, builder: MigrationCommandListBuilder): void;
     Rename(schema: string, name: string, newName: string, type: string, builder: MigrationCommandListBuilder): void;
+    SequenceOptions(schema: string, name: string, operation: SequenceOperation, model: IModel, builder: MigrationCommandListBuilder, forAlter: boolean): void;
     Transfer(newSchema: string, schema: string, name: string, type: string, builder: MigrationCommandListBuilder): void;
 }
 

package/Npgsql.EntityFrameworkCore.PostgreSQL.Migrations.Internal/internal/index.d.ts

@@ -7,39 +7,39 @@ import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint12
 
 // Import types from other namespaces
 import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { IReadOnlyList } from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, Void } 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 { IDiagnosticsLogger, IRelationalCommandDiagnosticsLogger } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics.js";
-import type { ICurrentDbContext, IDbContextOptions, IModelRuntimeInitializer } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import type { DbLoggerCategory$Migrations } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
-import type { IDesignTimeModel } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
-import * as Microsoft_EntityFrameworkCore_Migrations_Internal_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.Internal.js";
-import type { Migrator } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.Internal.js";
-import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.js";
-import type { HistoryRepository, HistoryRepositoryDependencies, HistoryRow, IHistoryRepository, IMigrationCommandExecutor, IMigrationsAssembly, IMigrationsDatabaseLock, IMigrationsModelDiffer, IMigrationsSqlGenerator, IMigrator, LockReleaseBehavior, MigrationCommand } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.js";
-import type { IDatabaseCreator, IDatabaseProvider, IExecutionStrategy, IRawSqlCommandBuilder, IRelationalConnection, ISqlGenerationHelper } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage.js";
-
-export abstract class NpgsqlHistoryRepository$protected {
-    protected readonly ExistsSql: string;
-    protected GetCreateCommands(): IReadOnlyList<MigrationCommand>;
-    protected InterpretExistsResult(value: unknown): boolean;
-}
+import type { IReadOnlyList_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { Task, Task_1 } from "@tsonic/dotnet/System.Threading.Tasks/internal/index.js";
+import type { CancellationToken } from "@tsonic/dotnet/System.Threading/internal/index.js";
+import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { IDiagnosticsLogger_1, IRelationalCommandDiagnosticsLogger } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
+import type { ICurrentDbContext, IDbContextOptions, IModelRuntimeInitializer } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import type { IDesignTimeModel } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Migrations_Internal_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.Internal/internal/index.js";
+import type { Migrator } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.Internal/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations/internal/index.js";
+import type { HistoryRepository, HistoryRepositoryDependencies, HistoryRow, IHistoryRepository, IMigrationCommandExecutor, IMigrationsAssembly, IMigrationsDatabaseLock, IMigrationsModelDiffer, IMigrationsSqlGenerator, IMigrator, LockReleaseBehavior, MigrationCommand } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations/internal/index.js";
+import type { IDatabaseCreator, IDatabaseProvider, IExecutionStrategy, IRawSqlCommandBuilder, IRelationalConnection, ISqlGenerationHelper } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage/internal/index.js";
+import type { DbLoggerCategory$Migrations } from "@tsonic/efcore/Microsoft.EntityFrameworkCore/internal/index.js";
+
+export interface NpgsqlHistoryRepository$instance extends HistoryRepository {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Migrations_Internal_NpgsqlHistoryRepository: never;
 
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Migrations_IHistoryRepository: never;
 
-export interface NpgsqlHistoryRepository$instance extends NpgsqlHistoryRepository$protected, HistoryRepository {
+    readonly ExistsSql: string;
     readonly LockReleaseBehavior: LockReleaseBehavior;
     AcquireDatabaseLock(): IMigrationsDatabaseLock;
-    AcquireDatabaseLockAsync(cancellationToken?: CancellationToken): Task<IMigrationsDatabaseLock>;
+    AcquireDatabaseLockAsync(cancellationToken?: CancellationToken): Task_1<IMigrationsDatabaseLock>;
     Exists(): boolean;
-    ExistsAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
-    GetAppliedMigrations(): IReadOnlyList<HistoryRow>;
-    GetAppliedMigrationsAsync(cancellationToken?: CancellationToken): Task<IReadOnlyList<HistoryRow>>;
+    ExistsAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
+    GetAppliedMigrations(): IReadOnlyList_1<HistoryRow>;
+    GetAppliedMigrationsAsync(cancellationToken?: CancellationToken): Task_1<IReadOnlyList_1<HistoryRow>>;
     GetBeginIfExistsScript(migrationId: string): string;
     GetBeginIfNotExistsScript(migrationId: string): string;
+    GetCreateCommands(): IReadOnlyList_1<MigrationCommand>;
     GetCreateIfNotExistsScript(): string;
     GetEndIfScript(): string;
+    InterpretExistsResult(value: unknown): boolean;
 }
 
 
@@ -51,13 +51,17 @@ export const NpgsqlHistoryRepository: {
 export type NpgsqlHistoryRepository = NpgsqlHistoryRepository$instance;
 
 export interface NpgsqlMigrator$instance extends Migrator {
+    readonly __tsonic_type_Npgsql_EntityFrameworkCore_PostgreSQL_Migrations_Internal_NpgsqlMigrator: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Migrations_IMigrator: never;
+
     Migrate(targetMigration: string): void;
     MigrateAsync(targetMigration: string, cancellationToken?: CancellationToken): Task;
 }
 
 
 export const NpgsqlMigrator: {
-    new(migrationsAssembly: IMigrationsAssembly, historyRepository: IHistoryRepository, databaseCreator: IDatabaseCreator, migrationsSqlGenerator: IMigrationsSqlGenerator, rawSqlCommandBuilder: IRawSqlCommandBuilder, migrationCommandExecutor: IMigrationCommandExecutor, connection: IRelationalConnection, sqlGenerationHelper: ISqlGenerationHelper, currentContext: ICurrentDbContext, modelRuntimeInitializer: IModelRuntimeInitializer, logger: IDiagnosticsLogger<DbLoggerCategory$Migrations>, commandLogger: IRelationalCommandDiagnosticsLogger, databaseProvider: IDatabaseProvider, migrationsModelDiffer: IMigrationsModelDiffer, designTimeModel: IDesignTimeModel, contextOptions: IDbContextOptions, executionStrategy: IExecutionStrategy): NpgsqlMigrator;
+    new(migrationsAssembly: IMigrationsAssembly, historyRepository: IHistoryRepository, databaseCreator: IDatabaseCreator, migrationsSqlGenerator: IMigrationsSqlGenerator, rawSqlCommandBuilder: IRawSqlCommandBuilder, migrationCommandExecutor: IMigrationCommandExecutor, connection: IRelationalConnection, sqlGenerationHelper: ISqlGenerationHelper, currentContext: ICurrentDbContext, modelRuntimeInitializer: IModelRuntimeInitializer, logger: IDiagnosticsLogger_1<DbLoggerCategory$Migrations>, commandLogger: IRelationalCommandDiagnosticsLogger, databaseProvider: IDatabaseProvider, migrationsModelDiffer: IMigrationsModelDiffer, designTimeModel: IDesignTimeModel, contextOptions: IDbContextOptions, executionStrategy: IExecutionStrategy): NpgsqlMigrator;
 };