@tsonic/efcore-npgsql 10.0.2 → 10.0.5

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

@@ -17,7 +17,6 @@ export interface FieldDescription$instance {
 
 
 export const FieldDescription: {
-    new(): FieldDescription;
 };
 
 

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

@@ -13,12 +13,10 @@ import type { DbContext } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js"
 import * as Microsoft_EntityFrameworkCore_Storage_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage.js";
 import type { ExecutionStrategy, ExecutionStrategyDependencies, IExecutionStrategy } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage.js";
 
-export abstract class NpgsqlRetryingExecutionStrategy$protected {
-    protected ShouldRetryOn(exception: Exception): boolean;
-}
-
+export interface NpgsqlRetryingExecutionStrategy$instance extends ExecutionStrategy {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategy: never;
 
-export interface NpgsqlRetryingExecutionStrategy$instance extends NpgsqlRetryingExecutionStrategy$protected, ExecutionStrategy {
+    ShouldRetryOn(exception: Exception): boolean;
 }
 
 

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

@@ -19,19 +19,17 @@ import type { IColumn, IEntityType, IIndex, IModel, IProperty, IRelationalModel,
 import type { CoreTypeMapping } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage.js";
 import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection.js";
 
-export abstract class NpgsqlAnnotationCodeGenerator$protected {
-    protected GenerateFluentApi(model: IModel, annotation: IAnnotation): MethodCallCodeFragment | undefined;
-    protected GenerateFluentApi(entityType: IEntityType, annotation: IAnnotation): MethodCallCodeFragment | undefined;
-    protected GenerateFluentApi(index: IIndex, annotation: IAnnotation): MethodCallCodeFragment | undefined;
-    protected IsHandledByConvention(model: IModel, annotation: IAnnotation): boolean;
-    protected IsHandledByConvention(index: IIndex, annotation: IAnnotation): boolean;
-    protected IsHandledByConvention(property: IProperty, annotation: IAnnotation): boolean;
-}
-
+export interface NpgsqlAnnotationCodeGenerator$instance extends AnnotationCodeGenerator {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Design_IAnnotationCodeGenerator: never;
 
-export interface NpgsqlAnnotationCodeGenerator$instance extends NpgsqlAnnotationCodeGenerator$protected, AnnotationCodeGenerator {
+    GenerateFluentApi(model: IModel, annotation: IAnnotation): MethodCallCodeFragment | undefined;
+    GenerateFluentApi(entityType: IEntityType, annotation: IAnnotation): MethodCallCodeFragment | undefined;
+    GenerateFluentApi(index: IIndex, annotation: IAnnotation): MethodCallCodeFragment | undefined;
     GenerateFluentApiCalls(model: IModel, annotations: IDictionary<System_Internal.String, IAnnotation>): IReadOnlyList<MethodCallCodeFragment>;
     GenerateFluentApiCalls(property: IProperty, annotations: IDictionary<System_Internal.String, IAnnotation>): IReadOnlyList<MethodCallCodeFragment>;
+    IsHandledByConvention(model: IModel, annotation: IAnnotation): boolean;
+    IsHandledByConvention(index: IIndex, annotation: IAnnotation): boolean;
+    IsHandledByConvention(property: IProperty, annotation: IAnnotation): boolean;
 }
 
 
@@ -42,12 +40,8 @@ export const NpgsqlAnnotationCodeGenerator: {
 
 export type NpgsqlAnnotationCodeGenerator = NpgsqlAnnotationCodeGenerator$instance;
 
-export abstract class NpgsqlCSharpRuntimeAnnotationCodeGenerator$protected {
-    protected AddNpgsqlTypeMappingTweaks(typeMapping: CoreTypeMapping, parameters: CSharpRuntimeAnnotationCodeGeneratorParameters): void;
-}
-
-
-export interface NpgsqlCSharpRuntimeAnnotationCodeGenerator$instance extends NpgsqlCSharpRuntimeAnnotationCodeGenerator$protected, RelationalCSharpRuntimeAnnotationCodeGenerator {
+export interface NpgsqlCSharpRuntimeAnnotationCodeGenerator$instance extends RelationalCSharpRuntimeAnnotationCodeGenerator {
+    AddNpgsqlTypeMappingTweaks(typeMapping: CoreTypeMapping, parameters: CSharpRuntimeAnnotationCodeGeneratorParameters): void;
     Create(typeMapping: CoreTypeMapping, parameters: CSharpRuntimeAnnotationCodeGeneratorParameters, valueComparer?: ValueComparer, keyValueComparer?: ValueComparer, providerValueComparer?: ValueComparer): boolean;
     Generate(model: IModel, parameters: CSharpRuntimeAnnotationCodeGeneratorParameters): void;
     Generate(model: IRelationalModel, parameters: CSharpRuntimeAnnotationCodeGeneratorParameters): void;
@@ -68,6 +62,8 @@ export const NpgsqlCSharpRuntimeAnnotationCodeGenerator: {
 export type NpgsqlCSharpRuntimeAnnotationCodeGenerator = NpgsqlCSharpRuntimeAnnotationCodeGenerator$instance;
 
 export interface NpgsqlDesignTimeServices$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Design_IDesignTimeServices: never;
+
     ConfigureDesignTimeServices(serviceCollection: IServiceCollection): void;
 }
 

package/Npgsql.EntityFrameworkCore.PostgreSQL.Extensions.Internal.d.ts

@@ -12,3 +12,6 @@ import type { ColumnExpression, SqlExpression } from '@tsonic/efcore/Microsoft.E
 
 // Public API exports (curated - no internal $instance/$views leakage)
 export { NpgsqlShapedQueryExpressionExtensions$instance as NpgsqlShapedQueryExpressionExtensions } from './Npgsql.EntityFrameworkCore.PostgreSQL.Extensions.Internal/internal/index.js';
+// Extension methods (C# using semantics)
+export type { ExtensionMethods_Npgsql_EntityFrameworkCore_PostgreSQL_Extensions_Internal as ExtensionMethods } from './__internal/extensions/index.js';
+

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

@@ -19,18 +19,16 @@ import type { DbContextOptionsBuilder } from "@tsonic/efcore/Microsoft.EntityFra
 import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection.js";
 
 export interface INpgsqlDataSourceConfigurationPlugin$instance {
+    readonly __tsonic_iface_Npgsql_EntityFrameworkCore_PostgreSQL_Infrastructure_INpgsqlDataSourceConfigurationPlugin: never;
+
     Configure(npgsqlDataSourceBuilder: NpgsqlDataSourceBuilder): void;
 }
 
 
 export type INpgsqlDataSourceConfigurationPlugin = INpgsqlDataSourceConfigurationPlugin$instance;
 
-export abstract class EntityFrameworkNpgsqlServicesBuilder$protected {
-    protected TryGetServiceCharacteristics(serviceType: Type): Nullable<ServiceCharacteristics>;
-}
-
-
-export interface EntityFrameworkNpgsqlServicesBuilder$instance extends EntityFrameworkNpgsqlServicesBuilder$protected, EntityFrameworkRelationalServicesBuilder {
+export interface EntityFrameworkNpgsqlServicesBuilder$instance extends EntityFrameworkRelationalServicesBuilder {
+    TryGetServiceCharacteristics(serviceType: Type): Nullable<ServiceCharacteristics>;
 }
 
 
@@ -42,6 +40,8 @@ export const EntityFrameworkNpgsqlServicesBuilder: {
 export type EntityFrameworkNpgsqlServicesBuilder = EntityFrameworkNpgsqlServicesBuilder$instance;
 
 export interface NpgsqlDbContextOptionsBuilder$instance extends RelationalDbContextOptionsBuilder<NpgsqlDbContextOptionsBuilder, NpgsqlOptionsExtension> {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IRelationalDbContextOptionsBuilderInfrastructure: never;
+
     ConfigureDataSource(dataSourceBuilderAction: Action<NpgsqlDataSourceBuilder>): NpgsqlDbContextOptionsBuilder;
     EnableRetryOnFailure(): NpgsqlDbContextOptionsBuilder;
     EnableRetryOnFailure(maxRetryCount: int): NpgsqlDbContextOptionsBuilder;

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

@@ -23,6 +23,8 @@ import type { IEntityType, IKey, IModel, IProperty, StoreObjectIdentifier } from
 import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection.js";
 
 export interface INpgsqlSingletonOptions$instance extends ISingletonOptions {
+    readonly __tsonic_iface_Npgsql_EntityFrameworkCore_PostgreSQL_Infrastructure_Internal_INpgsqlSingletonOptions: never;
+
     readonly PostgresVersion: Version;
     readonly IsPostgresVersionSet: boolean;
     readonly UseRedshift: boolean;
@@ -32,9 +34,13 @@ export interface INpgsqlSingletonOptions$instance extends ISingletonOptions {
 }
 
 
+export interface INpgsqlSingletonOptions$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.ISingletonOptions {}
+
 export type INpgsqlSingletonOptions = INpgsqlSingletonOptions$instance;
 
 export interface EnumDefinition$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly ClrType: Type;
     readonly Labels: IReadOnlyDictionary<unknown, System_Internal.String>;
     readonly NameTranslator: INpgsqlNameTranslator;
@@ -53,18 +59,16 @@ export const EnumDefinition: {
 
 export type EnumDefinition = EnumDefinition$instance;
 
-export abstract class NpgsqlModelValidator$protected {
-    protected ValidateCompatible(property: IProperty, duplicateProperty: IProperty, columnName: string, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    protected ValidateIdentityVersionCompatibility(model: IModel): void;
-    protected ValidateIndexIncludeProperties(model: IModel): void;
-    protected ValidateStoredProcedures(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    protected ValidateTypeMappings(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    protected ValidateValueGeneration(entityType: IEntityType, key: IKey, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-}
-
+export interface NpgsqlModelValidator$instance extends RelationalModelValidator {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelValidator: never;
 
-export interface NpgsqlModelValidator$instance extends NpgsqlModelValidator$protected, RelationalModelValidator {
     Validate(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
+    ValidateCompatible(property: IProperty, duplicateProperty: IProperty, columnName: string, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
+    ValidateIdentityVersionCompatibility(model: IModel): void;
+    ValidateIndexIncludeProperties(model: IModel): void;
+    ValidateStoredProcedures(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
+    ValidateTypeMappings(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
+    ValidateValueGeneration(entityType: IEntityType, key: IKey, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
 }
 
 
@@ -75,18 +79,15 @@ export const NpgsqlModelValidator: {
 
 export type NpgsqlModelValidator = NpgsqlModelValidator$instance;
 
-export abstract class NpgsqlOptionsExtension$protected {
-    protected Clone(): RelationalOptionsExtension;
-}
-
+export interface NpgsqlOptionsExtension$instance extends RelationalOptionsExtension {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptionsExtension: never;
 
-export interface NpgsqlOptionsExtension$instance extends NpgsqlOptionsExtension$protected, RelationalOptionsExtension {
     get AdminDatabase(): string | undefined;
-    set AdminDatabase(value: string);
+    set AdminDatabase(value: string | undefined);
     get DataSource(): DbDataSource | undefined;
-    set DataSource(value: DbDataSource);
+    set DataSource(value: DbDataSource | undefined);
     get DataSourceBuilderAction(): Action<NpgsqlDataSourceBuilder> | undefined;
-    set DataSourceBuilderAction(value: Action<NpgsqlDataSourceBuilder>);
+    set DataSourceBuilderAction(value: Action<NpgsqlDataSourceBuilder> | undefined);
     readonly EnumDefinitions: IReadOnlyList<EnumDefinition>;
     readonly Info: DbContextOptionsExtensionInfo;
     readonly IsPostgresVersionSet: boolean;
@@ -94,15 +95,16 @@ export interface NpgsqlOptionsExtension$instance extends NpgsqlOptionsExtension$
     readonly ParameterizedCollectionMode: ParameterTranslationMode;
     readonly PostgresVersion: Version;
     get ProvideClientCertificatesCallback(): ProvideClientCertificatesCallback | undefined;
-    set ProvideClientCertificatesCallback(value: ProvideClientCertificatesCallback);
+    set ProvideClientCertificatesCallback(value: ProvideClientCertificatesCallback | undefined);
     get ProvidePasswordCallback(): ProvidePasswordCallback | undefined;
-    set ProvidePasswordCallback(value: ProvidePasswordCallback);
+    set ProvidePasswordCallback(value: ProvidePasswordCallback | undefined);
     get RemoteCertificateValidationCallback(): RemoteCertificateValidationCallback | undefined;
-    set RemoteCertificateValidationCallback(value: RemoteCertificateValidationCallback);
+    set RemoteCertificateValidationCallback(value: RemoteCertificateValidationCallback | undefined);
     ReverseNullOrdering: boolean;
     UseRedshift: boolean;
     readonly UserRangeDefinitions: IReadOnlyList<UserRangeDefinition>;
     ApplyServices(services: IServiceCollection): void;
+    Clone(): RelationalOptionsExtension;
     Validate(options: IDbContextOptions): void;
     WithAdminDatabase(adminDatabase: string): NpgsqlOptionsExtension;
     WithConnection(connection: DbConnection): RelationalOptionsExtension;
@@ -131,6 +133,8 @@ export const NpgsqlOptionsExtension: {
 export type NpgsqlOptionsExtension = NpgsqlOptionsExtension$instance;
 
 export interface UserRangeDefinition$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly StoreTypeName: string;
     readonly StoreTypeSchema: string | undefined;
     readonly SubtypeClrType: Type;

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

@@ -17,6 +17,9 @@ import type { IDbContextOptions, ISingletonOptions } from "@tsonic/efcore/Micros
 import type { DbLoggerCategory$Scaffolding } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
 
 export interface NpgsqlSingletonOptions$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_ISingletonOptions: never;
+    readonly __tsonic_iface_Npgsql_EntityFrameworkCore_PostgreSQL_Infrastructure_Internal_INpgsqlSingletonOptions: never;
+
     EnumDefinitions: IReadOnlyList<EnumDefinition>;
     IsPostgresVersionSet: boolean;
     PostgresVersion: Version;

package/Npgsql.EntityFrameworkCore.PostgreSQL.Internal.d.ts

@@ -18,3 +18,6 @@ export { NpgsqlLoggerExtensions$instance as NpgsqlLoggerExtensions } from './Npg
 export { NpgsqlSingletonOptions as NpgsqlSingletonOptions } from './Npgsql.EntityFrameworkCore.PostgreSQL.Internal/internal/index.js';
 export { NpgsqlStrings$instance as NpgsqlStrings } from './Npgsql.EntityFrameworkCore.PostgreSQL.Internal/internal/index.js';
 export { NpgsqlResources$instance as NpgsqlResources } from './Npgsql.EntityFrameworkCore.PostgreSQL.Internal/internal/index.js';
+// Extension methods (C# using semantics)
+export type { ExtensionMethods_Npgsql_EntityFrameworkCore_PostgreSQL_Internal as ExtensionMethods } from './__internal/extensions/index.js';
+

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

@@ -40,7 +40,7 @@ export interface CockroachDbInterleaveInParent$instance {
     InterleavePrefix: List<System_Internal.String>;
     ParentTableName: string;
     get ParentTableSchema(): string | undefined;
-    set ParentTableSchema(value: string);
+    set ParentTableSchema(value: string | undefined);
 }
 
 
@@ -58,13 +58,12 @@ export interface PostgresCollation$instance {
     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;
@@ -82,7 +81,6 @@ export interface PostgresEnum$instance {
 
 
 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;
@@ -97,12 +95,12 @@ export interface PostgresExtension$instance {
     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;
@@ -116,21 +114,20 @@ export type PostgresExtension = PostgresExtension$instance;
 export interface PostgresRange$instance {
     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>;

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

@@ -24,6 +24,8 @@ import type { IConventionAnnotation, IConventionProperty, IEntityType, IIndex, I
 import type { IRelationalTypeMappingSource, RelationalTypeMapping } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage.js";
 
 export interface NpgsqlConventionSetBuilder$instance extends RelationalConventionSetBuilder {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_Infrastructure_IProviderConventionSetBuilder: never;
+
     CreateConventionSet(): ConventionSet;
 }
 
@@ -37,15 +39,14 @@ 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_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
 
-export interface NpgsqlPostgresModelFinalizingConvention$instance extends NpgsqlPostgresModelFinalizingConvention$protected {
+    DiscoverPostgresExtensions(property: IConventionProperty, typeMapping: RelationalTypeMapping, modelBuilder: IConventionModelBuilder): void;
     ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext<IConventionModelBuilder>): void;
+    ProcessRowVersionProperty(property: IConventionProperty, typeMapping: RelationalTypeMapping): void;
+    SetupEnums(modelBuilder: IConventionModelBuilder): void;
 }
 
 
@@ -56,15 +57,14 @@ export const 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_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<System_Internal.String, unknown>, entityType: IEntityType, runtimeEntityType: RuntimeEntityType, runtime: boolean): void;
+    ProcessIndexAnnotations(annotations: Dictionary<System_Internal.String, unknown>, index: IIndex, runtimeIndex: RuntimeIndex, runtime: boolean): void;
+    ProcessModelAnnotations(annotations: Dictionary<System_Internal.String, unknown>, model: IModel, runtimeModel: RuntimeModel, runtime: boolean): void;
+    ProcessPropertyAnnotations(annotations: Dictionary<System_Internal.String, unknown>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
 }
 
 
@@ -75,16 +75,15 @@ 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_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 +94,13 @@ 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_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;
+    Validate(property: IConventionProperty, storeObject: StoreObjectIdentifier): void;
 }
 
 
@@ -112,12 +111,18 @@ 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 {
+export interface NpgsqlValueGenerationConvention$instance extends RelationalValueGenerationConvention {
+    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<ValueGenerated>;
     ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation, oldAnnotation: IConventionAnnotation, context: IConventionContext<IConventionAnnotation>): void;
 }
 
@@ -130,13 +135,13 @@ export const NpgsqlValueGenerationConvention: {
 
 export type NpgsqlValueGenerationConvention = NpgsqlValueGenerationConvention$instance;
 
-export abstract class NpgsqlValueGenerationStrategyConvention$protected {
-    protected readonly Dependencies: ProviderConventionSetBuilderDependencies;
-    protected readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
-}
-
+export interface NpgsqlValueGenerationStrategyConvention$instance {
+    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 {
+    readonly Dependencies: ProviderConventionSetBuilderDependencies;
+    readonly RelationalDependencies: RelationalConventionSetBuilderDependencies;
     ProcessModelFinalizing(modelBuilder: IConventionModelBuilder, context: IConventionContext<IConventionModelBuilder>): void;
     ProcessModelInitialized(modelBuilder: IConventionModelBuilder, context: IConventionContext<IConventionModelBuilder>): void;
 }

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

@@ -14,6 +14,8 @@ import * as Microsoft_EntityFrameworkCore_Metadata_Internal from "@tsonic/efcore
 import type { IColumn, IRelationalAnnotationProvider, IRelationalModel, ITable, ITableIndex, RelationalAnnotationProvider, RelationalAnnotationProviderDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
 
 export interface IdentitySequenceOptionsData$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     IncrementBy: long;
     IsCyclic: boolean;
     MaxValue: Nullable<System_Internal.Int64>;
@@ -38,6 +40,8 @@ export const IdentitySequenceOptionsData: {
 export type IdentitySequenceOptionsData = IdentitySequenceOptionsData$instance;
 
 export interface NpgsqlAnnotationProvider$instance extends RelationalAnnotationProvider {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IRelationalAnnotationProvider: never;
+
     For(table: ITable, designTime: boolean): IEnumerable<IAnnotation>;
     For(column: IColumn, designTime: boolean): IEnumerable<IAnnotation>;
     For(index: ITableIndex, designTime: boolean): IEnumerable<IAnnotation>;

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

@@ -17,51 +17,49 @@ import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efco
 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";
 
-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_iface_Microsoft_EntityFrameworkCore_Migrations_IMigrationsSqlGenerator: never;
 
-export interface NpgsqlMigrationsSqlGenerator$instance extends NpgsqlMigrationsSqlGenerator$protected, MigrationsSqlGenerator {
+    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<MigrationOperation>, model?: IModel, options?: MigrationsSqlGenerationOptions): IReadOnlyList<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

@@ -21,14 +21,10 @@ import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efco
 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;
-}
-
+export interface NpgsqlHistoryRepository$instance extends HistoryRepository {
+    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>;
@@ -38,8 +34,10 @@ export interface NpgsqlHistoryRepository$instance extends NpgsqlHistoryRepositor
     GetAppliedMigrationsAsync(cancellationToken?: CancellationToken): Task<IReadOnlyList<HistoryRow>>;
     GetBeginIfExistsScript(migrationId: string): string;
     GetBeginIfNotExistsScript(migrationId: string): string;
+    GetCreateCommands(): IReadOnlyList<MigrationCommand>;
     GetCreateIfNotExistsScript(): string;
     GetEndIfScript(): string;
+    InterpretExistsResult(value: unknown): boolean;
 }
 
 
@@ -51,6 +49,8 @@ export const NpgsqlHistoryRepository: {
 export type NpgsqlHistoryRepository = NpgsqlHistoryRepository$instance;
 
 export interface NpgsqlMigrator$instance extends Migrator {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Migrations_IMigrator: never;
+
     Migrate(targetMigration: string): void;
     MigrateAsync(targetMigration: string, cancellationToken?: CancellationToken): Task;
 }