@tsonic/efcore-sqlite 10.0.5 → 10.0.7

package/Microsoft.EntityFrameworkCore/internal/index.d.ts

@@ -11,18 +11,18 @@ import type { ptr } from "@tsonic/core/types.js";
 // Import types from other namespaces
 import type { SqliteDbContextOptionsBuilder } from "../../Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
 import type { SqliteValueGenerationStrategy } from "../../Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
-import type { DbConnection } from "@tsonic/dotnet/System.Data.Common.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Action, Boolean as ClrBoolean, Byte, Int32, Nullable, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System.js";
-import type { DatabaseFacade } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import type { DbContext, DbContextOptionsBuilder, DbFunctions } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
-import type { ColumnBuilder, ComplexTypePropertyBuilder, IConventionEntityTypeBuilder, IConventionPropertyBuilder, OwnedNavigationTableBuilder, PropertyBuilder, SplitTableBuilder, TableBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Builders.js";
-import type { ConfigurationSource, IConventionEntityType, IConventionEntityTypeMappingFragment, IConventionProperty, IConventionRelationalPropertyOverrides, IMutableEntityType, IMutableEntityTypeMappingFragment, IMutableProperty, IMutableRelationalPropertyOverrides, IReadOnlyEntityType, IReadOnlyEntityTypeMappingFragment, IReadOnlyProperty, IReadOnlyRelationalPropertyOverrides, ITable, StoreObjectIdentifier } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
+import type { DbConnection } from "@tsonic/dotnet/System.Data.Common/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Action_1, Boolean as ClrBoolean, Byte, Int32, Nullable_1, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { DatabaseFacade } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import type { ColumnBuilder, ComplexTypePropertyBuilder, ComplexTypePropertyBuilder_1, IConventionEntityTypeBuilder, IConventionPropertyBuilder, OwnedNavigationTableBuilder, OwnedNavigationTableBuilder_2, PropertyBuilder, PropertyBuilder_1, SplitTableBuilder, SplitTableBuilder_1, TableBuilder, TableBuilder_1 } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Builders/internal/index.js";
+import type { ConfigurationSource, IConventionEntityType, IConventionEntityTypeMappingFragment, IConventionProperty, IConventionRelationalPropertyOverrides, IMutableEntityType, IMutableEntityTypeMappingFragment, IMutableProperty, IMutableRelationalPropertyOverrides, IReadOnlyEntityType, IReadOnlyEntityTypeMappingFragment, IReadOnlyProperty, IReadOnlyRelationalPropertyOverrides, ITable, StoreObjectIdentifier } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { DbContext, DbContextOptionsBuilder, DbContextOptionsBuilder_1, DbFunctions } from "@tsonic/efcore/Microsoft.EntityFrameworkCore/internal/index.js";
 
 export abstract class SqliteComplexTypePropertyBuilderExtensions$instance {
-    static HasSrid<TProperty>(propertyBuilder: ComplexTypePropertyBuilder<TProperty>, srid: int): ComplexTypePropertyBuilder<TProperty>;
+    static HasSrid<TProperty>(propertyBuilder: ComplexTypePropertyBuilder_1<TProperty>, srid: int): ComplexTypePropertyBuilder_1<TProperty>;
     static HasSrid(propertyBuilder: ComplexTypePropertyBuilder, srid: int): ComplexTypePropertyBuilder;
-    static UseAutoincrement<TProperty>(propertyBuilder: ComplexTypePropertyBuilder<TProperty>): ComplexTypePropertyBuilder<TProperty>;
+    static UseAutoincrement<TProperty>(propertyBuilder: ComplexTypePropertyBuilder_1<TProperty>): ComplexTypePropertyBuilder_1<TProperty>;
     static UseAutoincrement(propertyBuilder: ComplexTypePropertyBuilder): ComplexTypePropertyBuilder;
 }
 
@@ -37,14 +37,14 @@ export abstract class SqliteDatabaseFacadeExtensions$instance {
 export type SqliteDatabaseFacadeExtensions = SqliteDatabaseFacadeExtensions$instance;
 
 export abstract class SqliteDbContextOptionsBuilderExtensions$instance {
-    static UseSqlite<TContext extends DbContext>(optionsBuilder: DbContextOptionsBuilder<TContext>, sqliteOptionsAction?: Action<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder<TContext>;
-    static UseSqlite<TContext extends DbContext>(optionsBuilder: DbContextOptionsBuilder<TContext>, connection: DbConnection, sqliteOptionsAction?: Action<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder<TContext>;
-    static UseSqlite<TContext extends DbContext>(optionsBuilder: DbContextOptionsBuilder<TContext>, connection: DbConnection, contextOwnsConnection: boolean, sqliteOptionsAction?: Action<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder<TContext>;
-    static UseSqlite<TContext extends DbContext>(optionsBuilder: DbContextOptionsBuilder<TContext>, connectionString: string, sqliteOptionsAction?: Action<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder<TContext>;
-    static UseSqlite(optionsBuilder: DbContextOptionsBuilder, sqliteOptionsAction?: Action<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder;
-    static UseSqlite(optionsBuilder: DbContextOptionsBuilder, connection: DbConnection, sqliteOptionsAction?: Action<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder;
-    static UseSqlite(optionsBuilder: DbContextOptionsBuilder, connection: DbConnection, contextOwnsConnection: boolean, sqliteOptionsAction?: Action<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder;
-    static UseSqlite(optionsBuilder: DbContextOptionsBuilder, connectionString: string, sqliteOptionsAction?: Action<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder;
+    static UseSqlite<TContext extends DbContext>(optionsBuilder: DbContextOptionsBuilder_1<TContext>, sqliteOptionsAction?: Action_1<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder_1<TContext>;
+    static UseSqlite<TContext extends DbContext>(optionsBuilder: DbContextOptionsBuilder_1<TContext>, connection: DbConnection, sqliteOptionsAction?: Action_1<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder_1<TContext>;
+    static UseSqlite<TContext extends DbContext>(optionsBuilder: DbContextOptionsBuilder_1<TContext>, connection: DbConnection, contextOwnsConnection: boolean, sqliteOptionsAction?: Action_1<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder_1<TContext>;
+    static UseSqlite<TContext extends DbContext>(optionsBuilder: DbContextOptionsBuilder_1<TContext>, connectionString: string, sqliteOptionsAction?: Action_1<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder_1<TContext>;
+    static UseSqlite(optionsBuilder: DbContextOptionsBuilder, sqliteOptionsAction?: Action_1<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder;
+    static UseSqlite(optionsBuilder: DbContextOptionsBuilder, connection: DbConnection, sqliteOptionsAction?: Action_1<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder;
+    static UseSqlite(optionsBuilder: DbContextOptionsBuilder, connection: DbConnection, contextOwnsConnection: boolean, sqliteOptionsAction?: Action_1<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder;
+    static UseSqlite(optionsBuilder: DbContextOptionsBuilder, connectionString: string, sqliteOptionsAction?: Action_1<SqliteDbContextOptionsBuilder>): DbContextOptionsBuilder;
 }
 
 
@@ -63,49 +63,49 @@ export abstract class SqliteDbFunctionsExtensions$instance {
 export type SqliteDbFunctionsExtensions = SqliteDbFunctionsExtensions$instance;
 
 export abstract class SqliteEntityTypeBuilderExtensions$instance {
-    static CanUseSqlReturningClause(entityTypeBuilder: IConventionEntityTypeBuilder, useSqlReturningClause: Nullable<System_Internal.Boolean>, storeObject: StoreObjectIdentifier, fromDataAnnotation?: boolean): boolean;
-    static CanUseSqlReturningClause(entityTypeBuilder: IConventionEntityTypeBuilder, useSqlReturningClause: Nullable<System_Internal.Boolean>, fromDataAnnotation?: boolean): boolean;
-    static UseSqlReturningClause(entityTypeBuilder: IConventionEntityTypeBuilder, useSqlReturningClause: Nullable<System_Internal.Boolean>, storeObject: StoreObjectIdentifier, fromDataAnnotation?: boolean): IConventionEntityTypeBuilder | undefined;
-    static UseSqlReturningClause(entityTypeBuilder: IConventionEntityTypeBuilder, useSqlReturningClause: Nullable<System_Internal.Boolean>, fromDataAnnotation?: boolean): IConventionEntityTypeBuilder | undefined;
+    static CanUseSqlReturningClause(entityTypeBuilder: IConventionEntityTypeBuilder, useSqlReturningClause: Nullable_1<System_Internal.Boolean>, storeObject: StoreObjectIdentifier, fromDataAnnotation?: boolean): boolean;
+    static CanUseSqlReturningClause(entityTypeBuilder: IConventionEntityTypeBuilder, useSqlReturningClause: Nullable_1<System_Internal.Boolean>, fromDataAnnotation?: boolean): boolean;
+    static UseSqlReturningClause(entityTypeBuilder: IConventionEntityTypeBuilder, useSqlReturningClause: Nullable_1<System_Internal.Boolean>, storeObject: StoreObjectIdentifier, fromDataAnnotation?: boolean): IConventionEntityTypeBuilder | undefined;
+    static UseSqlReturningClause(entityTypeBuilder: IConventionEntityTypeBuilder, useSqlReturningClause: Nullable_1<System_Internal.Boolean>, fromDataAnnotation?: boolean): IConventionEntityTypeBuilder | undefined;
 }
 
 
 export type SqliteEntityTypeBuilderExtensions = SqliteEntityTypeBuilderExtensions$instance;
 
 export abstract class SqliteEntityTypeExtensions$instance {
-    static GetUseSqlReturningClauseConfigurationSource(entityType: IConventionEntityType, storeObject: StoreObjectIdentifier): Nullable<ConfigurationSource>;
-    static GetUseSqlReturningClauseConfigurationSource(entityType: IConventionEntityType): Nullable<ConfigurationSource>;
+    static GetUseSqlReturningClauseConfigurationSource(entityType: IConventionEntityType, storeObject: StoreObjectIdentifier): Nullable_1<ConfigurationSource>;
+    static GetUseSqlReturningClauseConfigurationSource(entityType: IConventionEntityType): Nullable_1<ConfigurationSource>;
     static IsSqlReturningClauseUsed(entityType: IReadOnlyEntityType, storeObject: StoreObjectIdentifier): boolean;
     static IsSqlReturningClauseUsed(entityType: IReadOnlyEntityType): boolean;
-    static UseSqlReturningClause(entityType: IConventionEntityType, useSqlReturningClause: Nullable<System_Internal.Boolean>, storeObject: StoreObjectIdentifier, fromDataAnnotation?: boolean): Nullable<System_Internal.Boolean>;
-    static UseSqlReturningClause(entityType: IConventionEntityType, useSqlReturningClause: Nullable<System_Internal.Boolean>, fromDataAnnotation?: boolean): Nullable<System_Internal.Boolean>;
-    static UseSqlReturningClause(entityType: IMutableEntityType, useSqlReturningClause: Nullable<System_Internal.Boolean>, storeObject: StoreObjectIdentifier): void;
-    static UseSqlReturningClause(entityType: IMutableEntityType, useSqlReturningClause: Nullable<System_Internal.Boolean>): void;
+    static UseSqlReturningClause(entityType: IConventionEntityType, useSqlReturningClause: Nullable_1<System_Internal.Boolean>, storeObject: StoreObjectIdentifier, fromDataAnnotation?: boolean): Nullable_1<System_Internal.Boolean>;
+    static UseSqlReturningClause(entityType: IConventionEntityType, useSqlReturningClause: Nullable_1<System_Internal.Boolean>, fromDataAnnotation?: boolean): Nullable_1<System_Internal.Boolean>;
+    static UseSqlReturningClause(entityType: IMutableEntityType, useSqlReturningClause: Nullable_1<System_Internal.Boolean>, storeObject: StoreObjectIdentifier): void;
+    static UseSqlReturningClause(entityType: IMutableEntityType, useSqlReturningClause: Nullable_1<System_Internal.Boolean>): void;
 }
 
 
 export type SqliteEntityTypeExtensions = SqliteEntityTypeExtensions$instance;
 
 export abstract class SqliteEntityTypeMappingFragmentExtensions$instance {
-    static GetUseSqlReturningClauseConfigurationSource(fragment: IConventionEntityTypeMappingFragment): Nullable<ConfigurationSource>;
+    static GetUseSqlReturningClauseConfigurationSource(fragment: IConventionEntityTypeMappingFragment): Nullable_1<ConfigurationSource>;
     static IsSqlReturningClauseUsed(fragment: IReadOnlyEntityTypeMappingFragment): boolean;
-    static UseSqlReturningClause(fragment: IConventionEntityTypeMappingFragment, useSqlReturningClause: Nullable<System_Internal.Boolean>, fromDataAnnotation?: boolean): Nullable<System_Internal.Boolean>;
-    static UseSqlReturningClause(fragment: IMutableEntityTypeMappingFragment, useSqlReturningClause: Nullable<System_Internal.Boolean>): void;
+    static UseSqlReturningClause(fragment: IConventionEntityTypeMappingFragment, useSqlReturningClause: Nullable_1<System_Internal.Boolean>, fromDataAnnotation?: boolean): Nullable_1<System_Internal.Boolean>;
+    static UseSqlReturningClause(fragment: IMutableEntityTypeMappingFragment, useSqlReturningClause: Nullable_1<System_Internal.Boolean>): void;
 }
 
 
 export type SqliteEntityTypeMappingFragmentExtensions = SqliteEntityTypeMappingFragmentExtensions$instance;
 
 export abstract class SqlitePropertyBuilderExtensions$instance {
-    static CanSetSrid(propertyBuilder: IConventionPropertyBuilder, srid: Nullable<System_Internal.Int32>, fromDataAnnotation?: boolean): boolean;
-    static CanSetValueGenerationStrategy(propertyBuilder: IConventionPropertyBuilder, strategy: Nullable<SqliteValueGenerationStrategy>, fromDataAnnotation?: boolean): boolean;
-    static HasSrid(propertyBuilder: IConventionPropertyBuilder, srid: Nullable<System_Internal.Int32>, fromDataAnnotation?: boolean): IConventionPropertyBuilder | undefined;
+    static CanSetSrid(propertyBuilder: IConventionPropertyBuilder, srid: Nullable_1<System_Internal.Int32>, fromDataAnnotation?: boolean): boolean;
+    static CanSetValueGenerationStrategy(propertyBuilder: IConventionPropertyBuilder, strategy: Nullable_1<SqliteValueGenerationStrategy>, fromDataAnnotation?: boolean): boolean;
+    static HasSrid(propertyBuilder: IConventionPropertyBuilder, srid: Nullable_1<System_Internal.Int32>, fromDataAnnotation?: boolean): IConventionPropertyBuilder | undefined;
     static HasSrid(propertyBuilder: PropertyBuilder, srid: int): PropertyBuilder;
-    static HasSrid<TProperty>(propertyBuilder: PropertyBuilder<TProperty>, srid: int): PropertyBuilder<TProperty>;
-    static HasValueGenerationStrategy(propertyBuilder: IConventionPropertyBuilder, strategy: Nullable<SqliteValueGenerationStrategy>, fromDataAnnotation?: boolean): IConventionPropertyBuilder | undefined;
+    static HasSrid<TProperty>(propertyBuilder: PropertyBuilder_1<TProperty>, srid: int): PropertyBuilder_1<TProperty>;
+    static HasValueGenerationStrategy(propertyBuilder: IConventionPropertyBuilder, strategy: Nullable_1<SqliteValueGenerationStrategy>, fromDataAnnotation?: boolean): IConventionPropertyBuilder | undefined;
     static UseAutoincrement(columnBuilder: ColumnBuilder): ColumnBuilder;
     static UseAutoincrement(propertyBuilder: PropertyBuilder): PropertyBuilder;
-    static UseAutoincrement<TProperty>(propertyBuilder: PropertyBuilder<TProperty>): PropertyBuilder<TProperty>;
+    static UseAutoincrement<TProperty>(propertyBuilder: PropertyBuilder_1<TProperty>): PropertyBuilder_1<TProperty>;
 }
 
 
@@ -113,23 +113,23 @@ export type SqlitePropertyBuilderExtensions = SqlitePropertyBuilderExtensions$in
 
 export abstract class SqlitePropertyExtensions$instance {
     static GetDefaultValueGenerationStrategy(property: IReadOnlyProperty): SqliteValueGenerationStrategy;
-    static GetSrid(property: IReadOnlyProperty, storeObject: StoreObjectIdentifier): Nullable<System_Internal.Int32>;
-    static GetSrid(property: IReadOnlyProperty): Nullable<System_Internal.Int32>;
-    static GetSridConfigurationSource(property: IConventionProperty): Nullable<ConfigurationSource>;
+    static GetSrid(property: IReadOnlyProperty, storeObject: StoreObjectIdentifier): Nullable_1<System_Internal.Int32>;
+    static GetSrid(property: IReadOnlyProperty): Nullable_1<System_Internal.Int32>;
+    static GetSridConfigurationSource(property: IConventionProperty): Nullable_1<ConfigurationSource>;
     static GetValueGenerationStrategy(property: IReadOnlyProperty, storeObject: StoreObjectIdentifier): SqliteValueGenerationStrategy;
     static GetValueGenerationStrategy(property: IReadOnlyProperty): SqliteValueGenerationStrategy;
-    static GetValueGenerationStrategy(overrides: IReadOnlyRelationalPropertyOverrides): Nullable<SqliteValueGenerationStrategy>;
-    static GetValueGenerationStrategyConfigurationSource(property: IConventionProperty, storeObject: StoreObjectIdentifier): Nullable<ConfigurationSource>;
-    static GetValueGenerationStrategyConfigurationSource(property: IConventionProperty): Nullable<ConfigurationSource>;
-    static GetValueGenerationStrategyConfigurationSource(overrides: IConventionRelationalPropertyOverrides): Nullable<ConfigurationSource>;
-    static SetSrid(property: IConventionProperty, value: Nullable<System_Internal.Int32>, fromDataAnnotation?: boolean): Nullable<System_Internal.Int32>;
-    static SetSrid(property: IMutableProperty, value: Nullable<System_Internal.Int32>): void;
-    static SetValueGenerationStrategy(property: IConventionProperty, value: Nullable<SqliteValueGenerationStrategy>, storeObject: StoreObjectIdentifier, fromDataAnnotation?: boolean): Nullable<SqliteValueGenerationStrategy>;
-    static SetValueGenerationStrategy(property: IConventionProperty, value: Nullable<SqliteValueGenerationStrategy>, fromDataAnnotation?: boolean): Nullable<SqliteValueGenerationStrategy>;
-    static SetValueGenerationStrategy(overrides: IConventionRelationalPropertyOverrides, value: Nullable<SqliteValueGenerationStrategy>, fromDataAnnotation?: boolean): Nullable<SqliteValueGenerationStrategy>;
-    static SetValueGenerationStrategy(property: IMutableProperty, value: Nullable<SqliteValueGenerationStrategy>, storeObject: StoreObjectIdentifier): void;
-    static SetValueGenerationStrategy(property: IMutableProperty, value: Nullable<SqliteValueGenerationStrategy>): void;
-    static SetValueGenerationStrategy(overrides: IMutableRelationalPropertyOverrides, value: Nullable<SqliteValueGenerationStrategy>): void;
+    static GetValueGenerationStrategy(overrides: IReadOnlyRelationalPropertyOverrides): Nullable_1<SqliteValueGenerationStrategy>;
+    static GetValueGenerationStrategyConfigurationSource(property: IConventionProperty, storeObject: StoreObjectIdentifier): Nullable_1<ConfigurationSource>;
+    static GetValueGenerationStrategyConfigurationSource(property: IConventionProperty): Nullable_1<ConfigurationSource>;
+    static GetValueGenerationStrategyConfigurationSource(overrides: IConventionRelationalPropertyOverrides): Nullable_1<ConfigurationSource>;
+    static SetSrid(property: IConventionProperty, value: Nullable_1<System_Internal.Int32>, fromDataAnnotation?: boolean): Nullable_1<System_Internal.Int32>;
+    static SetSrid(property: IMutableProperty, value: Nullable_1<System_Internal.Int32>): void;
+    static SetValueGenerationStrategy(property: IConventionProperty, value: Nullable_1<SqliteValueGenerationStrategy>, storeObject: StoreObjectIdentifier, fromDataAnnotation?: boolean): Nullable_1<SqliteValueGenerationStrategy>;
+    static SetValueGenerationStrategy(property: IConventionProperty, value: Nullable_1<SqliteValueGenerationStrategy>, fromDataAnnotation?: boolean): Nullable_1<SqliteValueGenerationStrategy>;
+    static SetValueGenerationStrategy(overrides: IConventionRelationalPropertyOverrides, value: Nullable_1<SqliteValueGenerationStrategy>, fromDataAnnotation?: boolean): Nullable_1<SqliteValueGenerationStrategy>;
+    static SetValueGenerationStrategy(property: IMutableProperty, value: Nullable_1<SqliteValueGenerationStrategy>, storeObject: StoreObjectIdentifier): void;
+    static SetValueGenerationStrategy(property: IMutableProperty, value: Nullable_1<SqliteValueGenerationStrategy>): void;
+    static SetValueGenerationStrategy(overrides: IMutableRelationalPropertyOverrides, value: Nullable_1<SqliteValueGenerationStrategy>): void;
 }
 
 
@@ -139,9 +139,9 @@ export abstract class SqliteTableBuilderExtensions$instance {
     static UseSqlReturningClause(tableBuilder: OwnedNavigationTableBuilder, useSqlReturningClause?: boolean): OwnedNavigationTableBuilder;
     static UseSqlReturningClause(tableBuilder: SplitTableBuilder, useSqlReturningClause?: boolean): SplitTableBuilder;
     static UseSqlReturningClause(tableBuilder: TableBuilder, useSqlReturningClause?: boolean): TableBuilder;
-    static UseSqlReturningClause<TOwnerEntity, TDependentEntity>(tableBuilder: OwnedNavigationTableBuilder<TOwnerEntity, TDependentEntity>, useSqlReturningClause?: boolean): OwnedNavigationTableBuilder<TOwnerEntity, TDependentEntity>;
-    static UseSqlReturningClause<TEntity>(tableBuilder: SplitTableBuilder<TEntity>, useSqlReturningClause?: boolean): SplitTableBuilder<TEntity>;
-    static UseSqlReturningClause<TEntity>(tableBuilder: TableBuilder<TEntity>, useSqlReturningClause?: boolean): TableBuilder<TEntity>;
+    static UseSqlReturningClause<TOwnerEntity, TDependentEntity>(tableBuilder: OwnedNavigationTableBuilder_2<TOwnerEntity, TDependentEntity>, useSqlReturningClause?: boolean): OwnedNavigationTableBuilder_2<TOwnerEntity, TDependentEntity>;
+    static UseSqlReturningClause<TEntity>(tableBuilder: SplitTableBuilder_1<TEntity>, useSqlReturningClause?: boolean): SplitTableBuilder_1<TEntity>;
+    static UseSqlReturningClause<TEntity>(tableBuilder: TableBuilder_1<TEntity>, useSqlReturningClause?: boolean): TableBuilder_1<TEntity>;
 }
 
 

package/Microsoft.EntityFrameworkCore.Diagnostics/internal/index.d.ts

@@ -7,14 +7,16 @@ import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint12
 
 // Import types from other namespaces
 import type { SqliteValueGenerationStrategy } from "../../Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Func, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System.js";
-import * as Microsoft_EntityFrameworkCore_Diagnostics_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics.js";
-import type { EventData, EventDefinitionBase } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics.js";
-import type { IReadOnlyProperty } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
-import type { EventId } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Func_3, Object as ClrObject, String as ClrString } from "@tsonic/dotnet/System/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Diagnostics_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
+import type { EventData, EventDefinitionBase } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
+import type { IReadOnlyProperty } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { EventId } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging/internal/index.js";
 
 export interface ConflictingValueGenerationStrategiesEventData$instance extends EventData {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Diagnostics_ConflictingValueGenerationStrategiesEventData: never;
+
     readonly OtherValueGenerationStrategy: string;
     readonly Property: IReadOnlyProperty;
     readonly SqliteValueGenerationStrategy: SqliteValueGenerationStrategy;
@@ -22,7 +24,7 @@ export interface ConflictingValueGenerationStrategiesEventData$instance extends
 
 
 export const ConflictingValueGenerationStrategiesEventData: {
-    new(eventDefinition: EventDefinitionBase, messageGenerator: Func<EventDefinitionBase, EventData, System_Internal.String>, sqliteValueGenerationStrategy: SqliteValueGenerationStrategy, otherValueGenerationStrategy: string, property: IReadOnlyProperty): ConflictingValueGenerationStrategiesEventData;
+    new(eventDefinition: EventDefinitionBase, messageGenerator: Func_3<EventDefinitionBase, EventData, System_Internal.String>, sqliteValueGenerationStrategy: SqliteValueGenerationStrategy, otherValueGenerationStrategy: string, property: IReadOnlyProperty): ConflictingValueGenerationStrategiesEventData;
 };
 
 

package/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.d.ts

@@ -8,14 +8,16 @@ import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint12
 // Import types from other namespaces
 import * as Microsoft_EntityFrameworkCore_Sqlite_Infrastructure_Internal_Internal from "../../Microsoft.EntityFrameworkCore.Sqlite.Infrastructure.Internal/internal/index.js";
 import type { SqliteOptionsExtension } from "../../Microsoft.EntityFrameworkCore.Sqlite.Infrastructure.Internal/internal/index.js";
-import type { DbConnection } from "@tsonic/dotnet/System.Data.Common.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Object as ClrObject, Void } from "@tsonic/dotnet/System.js";
-import * as Microsoft_EntityFrameworkCore_Infrastructure_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import type { IRelationalDbContextOptionsBuilderInfrastructure, RelationalDbContextOptionsBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import type { DbContextOptionsBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
-
-export interface SqliteDbContextOptionsBuilder$instance extends RelationalDbContextOptionsBuilder<SqliteDbContextOptionsBuilder, SqliteOptionsExtension> {
+import type { DbConnection } from "@tsonic/dotnet/System.Data.Common/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Boolean as ClrBoolean, Object as ClrObject, Void } from "@tsonic/dotnet/System/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Infrastructure_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import type { IRelationalDbContextOptionsBuilderInfrastructure, RelationalDbContextOptionsBuilder_2 } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import type { DbContextOptionsBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore/internal/index.js";
+
+export interface SqliteDbContextOptionsBuilder$instance extends RelationalDbContextOptionsBuilder_2<SqliteDbContextOptionsBuilder, SqliteOptionsExtension> {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_SqliteDbContextOptionsBuilder: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IRelationalDbContextOptionsBuilderInfrastructure: never;
 
 }

package/Microsoft.EntityFrameworkCore.Metadata/internal/index.d.ts

@@ -6,8 +6,8 @@
 import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';
 
 // Import types from other namespaces
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Enum, IComparable, IConvertible, IFormattable, Int32, ISpanFormattable } from "@tsonic/dotnet/System.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Enum, IComparable, IConvertible, IFormattable, Int32, ISpanFormattable } from "@tsonic/dotnet/System/internal/index.js";
 
 export enum SqliteValueGenerationStrategy {
     None = 0,

package/Microsoft.EntityFrameworkCore.Metadata.Conventions/internal/index.d.ts

@@ -10,17 +10,19 @@ import type { ptr } from "@tsonic/core/types.js";
 
 // Import types from other namespaces
 import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Dictionary } from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { Boolean as ClrBoolean, Nullable, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System.js";
-import type { ModelBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
-import type { 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, IPropertyAnnotationChangedConvention, RelationalRuntimeModelConvention, RelationalValueGenerationConvention, SharedTableConvention, StoreGenerationConvention } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions.js";
-import type { IConventionAnnotation, IConventionProperty, IProperty, RuntimeProperty, StoreObjectIdentifier, ValueGenerated } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
+import type { Dictionary_2 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { Boolean as ClrBoolean, Nullable_1, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { 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, IPropertyAnnotationChangedConvention, RelationalRuntimeModelConvention, RelationalValueGenerationConvention, SharedTableConvention, StoreGenerationConvention } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.Conventions/internal/index.js";
+import type { IConventionAnnotation, IConventionProperty, IProperty, RuntimeProperty, StoreObjectIdentifier, ValueGenerated } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { ModelBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore/internal/index.js";
 
 export interface SqliteConventionSetBuilder$instance extends RelationalConventionSetBuilder {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_SqliteConventionSetBuilder: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_Infrastructure_IProviderConventionSetBuilder: never;
 
     CreateConventionSet(): ConventionSet;
@@ -37,10 +39,12 @@ export const SqliteConventionSetBuilder: {
 export type SqliteConventionSetBuilder = SqliteConventionSetBuilder$instance;
 
 export interface SqliteRuntimeModelConvention$instance extends RelationalRuntimeModelConvention {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_SqliteRuntimeModelConvention: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizedConvention: never;
 
-    ProcessPropertyAnnotations(annotations: Dictionary<System_Internal.String, unknown>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
+    ProcessPropertyAnnotations(annotations: Dictionary_2<System_Internal.String, unknown>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
 }
 
 
@@ -52,6 +56,8 @@ export const SqliteRuntimeModelConvention: {
 export type SqliteRuntimeModelConvention = SqliteRuntimeModelConvention$instance;
 
 export interface SqliteSharedTableConvention$instance extends SharedTableConvention {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_SqliteSharedTableConvention: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
 
@@ -67,11 +73,13 @@ export const SqliteSharedTableConvention: {
 export type SqliteSharedTableConvention = SqliteSharedTableConvention$instance;
 
 export interface SqliteStoreGenerationConvention$instance extends StoreGenerationConvention {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_SqliteStoreGenerationConvention: 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;
 
-    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;
 }
 
@@ -84,6 +92,8 @@ export const SqliteStoreGenerationConvention: {
 export type SqliteStoreGenerationConvention = SqliteStoreGenerationConvention$instance;
 
 export interface SqliteValueGenerationConvention$instance extends RelationalValueGenerationConvention {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Metadata_Conventions_SqliteValueGenerationConvention: 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;
@@ -94,8 +104,8 @@ export interface SqliteValueGenerationConvention$instance extends RelationalValu
     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;
+    GetValueGenerated(property: IConventionProperty): Nullable_1<ValueGenerated>;
+    ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation, oldAnnotation: IConventionAnnotation, context: IConventionContext_1<IConventionAnnotation>): void;
 }
 
 

package/Microsoft.EntityFrameworkCore.Migrations/internal/index.d.ts

@@ -6,21 +6,23 @@
 import type { sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';
 
 // Import types from other namespaces
-import type { IReadOnlyList } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System.js";
-import type { IModel, IRelationalAnnotationProvider } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
-import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.js";
-import type { IMigrationsSqlGenerator, MigrationBuilder, MigrationCommand, MigrationCommandListBuilder, MigrationsSqlGenerationOptions, MigrationsSqlGenerator, MigrationsSqlGeneratorDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.js";
-import type { AddCheckConstraintOperation, AddColumnOperation, AddForeignKeyOperation, AddPrimaryKeyOperation, AddUniqueConstraintOperation, AlterColumnOperation, AlterDatabaseOperation, AlterSequenceOperation, ColumnOperation, CreateSequenceOperation, CreateTableOperation, DropCheckConstraintOperation, DropColumnOperation, DropForeignKeyOperation, DropIndexOperation, DropPrimaryKeyOperation, DropSchemaOperation, DropSequenceOperation, DropUniqueConstraintOperation, EnsureSchemaOperation, MigrationOperation, RenameColumnOperation, RenameIndexOperation, RenameSequenceOperation, RenameTableOperation, RestartSequenceOperation } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.Operations.js";
+import type { IReadOnlyList_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { IModel, IRelationalAnnotationProvider } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { AddCheckConstraintOperation, AddColumnOperation, AddForeignKeyOperation, AddPrimaryKeyOperation, AddUniqueConstraintOperation, AlterColumnOperation, AlterDatabaseOperation, AlterSequenceOperation, ColumnOperation, CreateSequenceOperation, CreateTableOperation, DropCheckConstraintOperation, DropColumnOperation, DropForeignKeyOperation, DropIndexOperation, DropPrimaryKeyOperation, DropSchemaOperation, DropSequenceOperation, DropUniqueConstraintOperation, EnsureSchemaOperation, MigrationOperation, RenameColumnOperation, RenameIndexOperation, RenameSequenceOperation, RenameTableOperation, RestartSequenceOperation } 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, MigrationBuilder, MigrationCommand, MigrationCommandListBuilder, MigrationsSqlGenerationOptions, MigrationsSqlGenerator, MigrationsSqlGeneratorDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations/internal/index.js";
 
 export interface SqliteMigrationsSqlGenerator$instance extends MigrationsSqlGenerator {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Migrations_SqliteMigrationsSqlGenerator: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Migrations_IMigrationsSqlGenerator: never;
 
     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;
     CreateTableColumns(operation: CreateTableOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    Generate(operations: IReadOnlyList<MigrationOperation>, model?: IModel, options?: MigrationsSqlGenerationOptions): IReadOnlyList<MigrationCommand>;
+    Generate(operations: IReadOnlyList_1<MigrationOperation>, model?: IModel, options?: MigrationsSqlGenerationOptions): IReadOnlyList_1<MigrationCommand>;
     Generate(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
     Generate(operation: AddColumnOperation, model: IModel, builder: MigrationCommandListBuilder, terminate: boolean): void;
     Generate(operation: DropIndexOperation, model: IModel, builder: MigrationCommandListBuilder, terminate: boolean): void;

package/Microsoft.EntityFrameworkCore.Sqlite.Design.Internal/internal/index.d.ts

@@ -6,21 +6,23 @@
 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 { IDictionary, IReadOnlyList } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Boolean as ClrBoolean, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System.js";
-import * as Microsoft_EntityFrameworkCore_Design_Internal_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Design.Internal.js";
-import type { CSharpRuntimeAnnotationCodeGeneratorDependencies, CSharpRuntimeAnnotationCodeGeneratorParameters, RelationalCSharpRuntimeAnnotationCodeGenerator, RelationalCSharpRuntimeAnnotationCodeGeneratorDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Design.Internal.js";
-import * as Microsoft_EntityFrameworkCore_Design_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Design.js";
-import type { AnnotationCodeGenerator, AnnotationCodeGeneratorDependencies, IAnnotationCodeGenerator, IDesignTimeServices, MethodCallCodeFragment } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Design.js";
-import type { IAnnotation } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import type { IColumn, IProperty, IRelationalModel } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
-import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection.js";
+import type { IDictionary_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, Object as ClrObject, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Design_Internal_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Design.Internal/internal/index.js";
+import type { CSharpRuntimeAnnotationCodeGeneratorDependencies, CSharpRuntimeAnnotationCodeGeneratorParameters, RelationalCSharpRuntimeAnnotationCodeGenerator, RelationalCSharpRuntimeAnnotationCodeGeneratorDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Design.Internal/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Design_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Design/internal/index.js";
+import type { AnnotationCodeGenerator, AnnotationCodeGeneratorDependencies, IAnnotationCodeGenerator, IDesignTimeServices, MethodCallCodeFragment } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Design/internal/index.js";
+import type { IAnnotation } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import type { IColumn, IProperty, IRelationalModel } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection/internal/index.js";
 
 export interface SqliteAnnotationCodeGenerator$instance extends AnnotationCodeGenerator {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Sqlite_Design_Internal_SqliteAnnotationCodeGenerator: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Design_IAnnotationCodeGenerator: never;
 
-    GenerateFluentApiCalls(property: IProperty, annotations: IDictionary<System_Internal.String, IAnnotation>): IReadOnlyList<MethodCallCodeFragment>;
+    GenerateFluentApiCalls(property: IProperty, annotations: IDictionary_2<System_Internal.String, IAnnotation>): IReadOnlyList_1<MethodCallCodeFragment>;
     IsHandledByConvention(property: IProperty, annotation: IAnnotation): boolean;
 }
 
@@ -33,6 +35,8 @@ export const SqliteAnnotationCodeGenerator: {
 export type SqliteAnnotationCodeGenerator = SqliteAnnotationCodeGenerator$instance;
 
 export interface SqliteCSharpRuntimeAnnotationCodeGenerator$instance extends RelationalCSharpRuntimeAnnotationCodeGenerator {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Sqlite_Design_Internal_SqliteCSharpRuntimeAnnotationCodeGenerator: never;
+
     Generate(model: IRelationalModel, parameters: CSharpRuntimeAnnotationCodeGeneratorParameters): void;
     Generate(property: IProperty, parameters: CSharpRuntimeAnnotationCodeGeneratorParameters): void;
     Generate(column: IColumn, parameters: CSharpRuntimeAnnotationCodeGeneratorParameters): void;
@@ -47,6 +51,8 @@ export const SqliteCSharpRuntimeAnnotationCodeGenerator: {
 export type SqliteCSharpRuntimeAnnotationCodeGenerator = SqliteCSharpRuntimeAnnotationCodeGenerator$instance;
 
 export interface SqliteDesignTimeServices$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Sqlite_Design_Internal_SqliteDesignTimeServices: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Design_IDesignTimeServices: never;
 
     ConfigureDesignTimeServices(serviceCollection: IServiceCollection): void;

package/Microsoft.EntityFrameworkCore.Sqlite.Diagnostics.Internal/internal/index.d.ts

@@ -7,11 +7,13 @@ 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 { Func, String as ClrString, Type } from "@tsonic/dotnet/System.js";
-import * as Microsoft_EntityFrameworkCore_Diagnostics_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics.js";
-import type { EventData, EventDefinitionBase, RelationalLoggingDefinitions } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics.js";
+import type { Func_3, String as ClrString, Type } from "@tsonic/dotnet/System/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Diagnostics_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
+import type { EventData, EventDefinitionBase, RelationalLoggingDefinitions } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
 
 export interface SqliteLoggingDefinitions$instance extends RelationalLoggingDefinitions {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Sqlite_Diagnostics_Internal_SqliteLoggingDefinitions: never;
+
     LogSchemaConfigured: EventDefinitionBase | undefined;
     LogSequenceConfigured: EventDefinitionBase | undefined;
     LogUsingSchemaSelectionsWarning: EventDefinitionBase | undefined;
@@ -42,25 +44,29 @@ export const SqliteLoggingDefinitions: {
 export type SqliteLoggingDefinitions = SqliteLoggingDefinitions$instance;
 
 export interface TableRebuildEventData$instance extends EventData {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Sqlite_Diagnostics_Internal_TableRebuildEventData: never;
+
     readonly OperationType: Type;
     readonly TableName: string | undefined;
 }
 
 
 export const TableRebuildEventData: {
-    new(eventDefinition: EventDefinitionBase, messageGenerator: Func<EventDefinitionBase, EventData, System_Internal.String>, operationType: Type, tableName: string): TableRebuildEventData;
+    new(eventDefinition: EventDefinitionBase, messageGenerator: Func_3<EventDefinitionBase, EventData, System_Internal.String>, operationType: Type, tableName: string): TableRebuildEventData;
 };
 
 
 export type TableRebuildEventData = TableRebuildEventData$instance;
 
 export interface UnexpectedConnectionTypeEventData$instance extends EventData {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Sqlite_Diagnostics_Internal_UnexpectedConnectionTypeEventData: never;
+
     readonly ConnectionType: Type;
 }
 
 
 export const UnexpectedConnectionTypeEventData: {
-    new(eventDefinition: EventDefinitionBase, messageGenerator: Func<EventDefinitionBase, EventData, System_Internal.String>, connectionType: Type): UnexpectedConnectionTypeEventData;
+    new(eventDefinition: EventDefinitionBase, messageGenerator: Func_3<EventDefinitionBase, EventData, System_Internal.String>, connectionType: Type): UnexpectedConnectionTypeEventData;
 };
 
 

package/Microsoft.EntityFrameworkCore.Sqlite.Infrastructure.Internal/internal/index.d.ts

@@ -10,25 +10,27 @@ import type { ptr } from "@tsonic/core/types.js";
 
 // 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, String as ClrString, Void } from "@tsonic/dotnet/System.js";
-import type { IDiagnosticsLogger } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics.js";
-import * as Microsoft_EntityFrameworkCore_Infrastructure_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import type { DbContextOptionsExtensionInfo, IDbContextOptionsExtension, IModelValidator, ModelValidatorDependencies, RelationalModelValidator, RelationalModelValidatorDependencies, RelationalOptionsExtension } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure.js";
-import type { DbLoggerCategory$Model$Validation } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
-import type { IEntityType, IKey, IModel, IProperty, StoreObjectIdentifier } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
-import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection.js";
+import type { IReadOnlyList_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { Boolean as ClrBoolean, String as ClrString, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { IDiagnosticsLogger_1 } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
+import * as Microsoft_EntityFrameworkCore_Infrastructure_Internal from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import type { DbContextOptionsExtensionInfo, IDbContextOptionsExtension, IModelValidator, ModelValidatorDependencies, RelationalModelValidator, RelationalModelValidatorDependencies, RelationalOptionsExtension } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
+import type { IEntityType, IKey, IModel, IProperty, StoreObjectIdentifier } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
+import type { DbLoggerCategory$Model$Validation } from "@tsonic/efcore/Microsoft.EntityFrameworkCore/internal/index.js";
+import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection/internal/index.js";
 
 export interface SqliteModelValidator$instance extends RelationalModelValidator {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Sqlite_Infrastructure_Internal_SqliteModelValidator: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelValidator: never;
 
-    Validate(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    ValidateCompatible(property: IProperty, duplicateProperty: IProperty, columnName: string, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    ValidateNoSchemas(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    ValidateNoSequences(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    ValidateNoStoredProcedures(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    ValidateSharedTableCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    ValidateValueGeneration(entityType: IEntityType, key: IKey, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
+    Validate(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory$Model$Validation>): void;
+    ValidateCompatible(property: IProperty, duplicateProperty: IProperty, columnName: string, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory$Model$Validation>): void;
+    ValidateNoSchemas(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory$Model$Validation>): void;
+    ValidateNoSequences(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory$Model$Validation>): void;
+    ValidateNoStoredProcedures(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory$Model$Validation>): void;
+    ValidateSharedTableCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory$Model$Validation>): void;
+    ValidateValueGeneration(entityType: IEntityType, key: IKey, logger: IDiagnosticsLogger_1<DbLoggerCategory$Model$Validation>): void;
 }
 
 
@@ -40,6 +42,8 @@ export const SqliteModelValidator: {
 export type SqliteModelValidator = SqliteModelValidator$instance;
 
 export interface SqliteOptionsExtension$instance extends RelationalOptionsExtension {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Sqlite_Infrastructure_Internal_SqliteOptionsExtension: never;
+
     readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptionsExtension: never;
 
     readonly Info: DbContextOptionsExtensionInfo;