@tsonic/efcore-sqlite 10.0.2 → 10.0.5

package/Microsoft.Data.Sqlite/internal/index.d.ts

@@ -51,17 +51,16 @@ export enum SqliteType {
 }
 
 
-export abstract class SqliteBlob$protected {
-    protected Dispose(disposing: boolean): void;
-}
-
+export interface SqliteBlob$instance extends Stream {
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqliteBlob$instance extends SqliteBlob$protected, Stream {
     readonly CanRead: boolean;
     readonly CanSeek: boolean;
     readonly CanWrite: boolean;
     readonly Length: long;
     Position: long;
+    Dispose(disposing: boolean): void;
     Flush(): void;
     Read(buffer: byte[], offset: int, count: int): int;
     Read(buffer: Span<System_Internal.Byte>): int;
@@ -80,31 +79,35 @@ export const SqliteBlob: {
 
 export type SqliteBlob = SqliteBlob$instance;
 
-export abstract class SqliteCommand$protected {
-    protected DataReader: SqliteDataReader | undefined;
-    protected DbConnection: DbConnection | undefined;
-    protected readonly DbParameterCollection: DbParameterCollection;
-    protected DbTransaction: DbTransaction | undefined;
-    protected CreateDbParameter(): DbParameter;
-    protected Dispose(disposing: boolean): void;
-    protected ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
-    protected ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task<DbDataReader>;
-}
-
+export interface SqliteCommand$instance extends DbCommand {
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_Data_IDbCommand: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqliteCommand$instance extends SqliteCommand$protected, DbCommand {
     CommandText: string;
     CommandTimeout: int;
     CommandType: CommandType;
     get Connection(): SqliteConnection | undefined;
-    set Connection(value: SqliteConnection);
+    set Connection(value: SqliteConnection | undefined);
+    get DataReader(): SqliteDataReader | undefined;
+    set DataReader(value: SqliteDataReader | undefined);
+    get DbConnection(): DbConnection | undefined;
+    set DbConnection(value: DbConnection | undefined);
+    readonly DbParameterCollection: DbParameterCollection;
+    get DbTransaction(): DbTransaction | undefined;
+    set DbTransaction(value: DbTransaction | undefined);
     DesignTimeVisible: boolean;
     readonly Parameters: SqliteParameterCollection;
     get Transaction(): SqliteTransaction | undefined;
-    set Transaction(value: SqliteTransaction);
+    set Transaction(value: SqliteTransaction | undefined);
     UpdatedRowSource: UpdateRowSource;
     Cancel(): void;
+    CreateDbParameter(): DbParameter;
     CreateParameter(): SqliteParameter;
+    Dispose(disposing: boolean): void;
+    ExecuteDbDataReader(behavior: CommandBehavior): DbDataReader;
+    ExecuteDbDataReaderAsync(behavior: CommandBehavior, cancellationToken: CancellationToken): Task<DbDataReader>;
     ExecuteNonQuery(): int;
     ExecuteReader(): SqliteDataReader;
     ExecuteReader(behavior: CommandBehavior): SqliteDataReader;
@@ -127,25 +130,25 @@ export const SqliteCommand: {
 
 export type SqliteCommand = SqliteCommand$instance;
 
-export abstract class SqliteConnection$protected {
-    protected readonly DbProviderFactory: DbProviderFactory;
-    protected Transaction: SqliteTransaction | undefined;
-    protected BeginDbTransaction(isolationLevel: IsolationLevel): DbTransaction;
-    protected CreateDbCommand(): DbCommand;
-    protected Dispose(disposing: boolean): void;
-}
-
+export interface SqliteConnection$instance extends DbConnection {
+    readonly __tsonic_iface_System_ComponentModel_IComponent: never;
+    readonly __tsonic_iface_System_Data_IDbConnection: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqliteConnection$instance extends SqliteConnection$protected, DbConnection {
     ConnectionString: string;
     readonly Database: string;
     readonly DataSource: string;
+    readonly DbProviderFactory: DbProviderFactory;
     DefaultTimeout: int;
     readonly Handle: sqlite3 | undefined;
     readonly ServerVersion: string;
     readonly State: ConnectionState;
+    get Transaction(): SqliteTransaction | undefined;
+    set Transaction(value: SqliteTransaction | undefined);
     BackupDatabase(destination: SqliteConnection): void;
     BackupDatabase(destination: SqliteConnection, destinationName: string, sourceName: string): void;
+    BeginDbTransaction(isolationLevel: IsolationLevel): DbTransaction;
     BeginTransaction(): SqliteTransaction;
     BeginTransaction(deferred: boolean): SqliteTransaction;
     BeginTransaction(isolationLevel: IsolationLevel): SqliteTransaction;
@@ -203,6 +206,7 @@ export interface SqliteConnection$instance extends SqliteConnection$protected, D
     CreateCollation(name: string, comparison: Comparison<System_Internal.String>): void;
     CreateCollation<T>(name: string, state: T, comparison: Func<T, System_Internal.String, System_Internal.String, System_Internal.Int32>): void;
     CreateCommand(): SqliteCommand;
+    CreateDbCommand(): DbCommand;
     CreateFunction<TResult>(name: string, function_: Func<TResult>, isDeterministic?: boolean): void;
     CreateFunction<T1, TResult>(name: string, function_: Func<T1, TResult>, isDeterministic?: boolean): void;
     CreateFunction<T1, T2, TResult>(name: string, function_: Func<T1, T2, TResult>, isDeterministic?: boolean): void;
@@ -236,6 +240,7 @@ export interface SqliteConnection$instance extends SqliteConnection$protected, D
     CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(name: string, state: TState, function_: Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>, isDeterministic?: boolean): void;
     CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(name: string, state: TState, function_: Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>, isDeterministic?: boolean): void;
     CreateFunction<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(name: string, state: TState, function_: Func<TState, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>, isDeterministic?: boolean): void;
+    Dispose(disposing: boolean): void;
     EnableExtensions(enable?: boolean): void;
     GetSchema(): DataTable;
     GetSchema(collectionName: string): DataTable;
@@ -256,12 +261,16 @@ export const SqliteConnection: {
 export type SqliteConnection = SqliteConnection$instance;
 
 export interface SqliteConnectionStringBuilder$instance extends DbConnectionStringBuilder {
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IDictionary: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_ComponentModel_ICustomTypeDescriptor: never;
+
     Cache: SqliteCacheMode;
     DataSource: string;
     DefaultTimeout: int;
     ForeignKeys: Nullable<System_Internal.Boolean>;
-    get Item(): unknown | undefined;
-    set Item(value: unknown);
+    [keyword: string]: unknown | undefined;
     readonly Keys: ICollection;
     Mode: SqliteOpenMode;
     Password: string;
@@ -269,7 +278,7 @@ export interface SqliteConnectionStringBuilder$instance extends DbConnectionStri
     RecursiveTriggers: boolean;
     readonly Values: ICollection;
     get Vfs(): string | undefined;
-    set Vfs(value: string);
+    set Vfs(value: string | undefined);
     Clear(): void;
     ContainsKey(keyword: string): boolean;
     Remove(keyword: string): boolean;
@@ -286,12 +295,13 @@ export const SqliteConnectionStringBuilder: {
 
 export type SqliteConnectionStringBuilder = SqliteConnectionStringBuilder$instance;
 
-export abstract class SqliteDataReader$protected {
-    protected Dispose(disposing: boolean): void;
-}
-
+export interface SqliteDataReader$instance extends DbDataReader {
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Data_IDataReader: never;
+    readonly __tsonic_iface_System_Data_IDataRecord: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqliteDataReader$instance extends SqliteDataReader$protected, DbDataReader {
     readonly Depth: int;
     readonly FieldCount: int;
     readonly Handle: sqlite3_stmt | undefined;
@@ -299,6 +309,7 @@ export interface SqliteDataReader$instance extends SqliteDataReader$protected, D
     readonly IsClosed: boolean;
     readonly RecordsAffected: int;
     Close(): void;
+    Dispose(disposing: boolean): void;
     get_Item(name: string): unknown;
     get_Item(ordinal: int): unknown;
     GetBoolean(ordinal: int): boolean;
@@ -335,13 +346,14 @@ export interface SqliteDataReader$instance extends SqliteDataReader$protected, D
 
 
 export const SqliteDataReader: {
-    new(): SqliteDataReader;
 };
 
 
 export type SqliteDataReader = SqliteDataReader$instance;
 
 export interface SqliteException$instance extends DbException {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
     readonly SqliteErrorCode: int;
     readonly SqliteExtendedErrorCode: int;
 }
@@ -365,7 +377,6 @@ export interface SqliteFactory$instance extends DbProviderFactory {
 
 
 export const SqliteFactory: {
-    new(): SqliteFactory;
     readonly Instance: SqliteFactory;
 };
 
@@ -373,6 +384,9 @@ export const SqliteFactory: {
 export type SqliteFactory = SqliteFactory$instance;
 
 export interface SqliteParameter$instance extends DbParameter {
+    readonly __tsonic_iface_System_Data_IDataParameter: never;
+    readonly __tsonic_iface_System_Data_IDbDataParameter: never;
+
     DbType: DbType;
     Direction: ParameterDirection;
     IsNullable: boolean;
@@ -382,7 +396,7 @@ export interface SqliteParameter$instance extends DbParameter {
     SourceColumnNullMapping: boolean;
     SqliteType: SqliteType;
     get Value(): unknown | undefined;
-    set Value(value: unknown);
+    set Value(value: unknown | undefined);
     ResetDbType(): void;
     ResetSqliteType(): void;
 }
@@ -399,15 +413,12 @@ export const SqliteParameter: {
 
 export type SqliteParameter = SqliteParameter$instance;
 
-export abstract class SqliteParameterCollection$protected {
-    protected GetParameter(index: int): DbParameter;
-    protected GetParameter(parameterName: string): DbParameter;
-    protected SetParameter(index: int, value: DbParameter): void;
-    protected SetParameter(parameterName: string, value: DbParameter): void;
-}
-
+export interface SqliteParameterCollection$instance extends DbParameterCollection {
+    readonly __tsonic_iface_System_Collections_ICollection: never;
+    readonly __tsonic_iface_System_Collections_IEnumerable: never;
+    readonly __tsonic_iface_System_Collections_IList: never;
+    readonly __tsonic_iface_System_Data_IDataParameterCollection: never;
 
-export interface SqliteParameterCollection$instance extends SqliteParameterCollection$protected, DbParameterCollection {
     readonly Count: int;
     readonly SyncRoot: unknown;
     Add(value: unknown): int;
@@ -427,6 +438,8 @@ export interface SqliteParameterCollection$instance extends SqliteParameterColle
     get_Item(index: int): SqliteParameter;
     get_Item(parameterName: string): SqliteParameter;
     GetEnumerator(): IEnumerator;
+    GetParameter(index: int): DbParameter;
+    GetParameter(parameterName: string): DbParameter;
     IndexOf(value: unknown): int;
     IndexOf(value: SqliteParameter): int;
     IndexOf(parameterName: string): int;
@@ -438,27 +451,28 @@ export interface SqliteParameterCollection$instance extends SqliteParameterColle
     RemoveAt(parameterName: string): void;
     set_Item(index: int, value: SqliteParameter): void;
     set_Item(parameterName: string, value: SqliteParameter): void;
+    SetParameter(index: int, value: DbParameter): void;
+    SetParameter(parameterName: string, value: DbParameter): void;
 }
 
 
-export const SqliteParameterCollection: {
-    new(): SqliteParameterCollection;
+export const SqliteParameterCollection: (abstract new() => SqliteParameterCollection) & {
 };
 
 
 export type SqliteParameterCollection = SqliteParameterCollection$instance;
 
-export abstract class SqliteTransaction$protected {
-    protected readonly DbConnection: DbConnection | undefined;
-    protected Dispose(disposing: boolean): void;
-}
-
+export interface SqliteTransaction$instance extends DbTransaction {
+    readonly __tsonic_iface_System_Data_IDbTransaction: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface SqliteTransaction$instance extends SqliteTransaction$protected, DbTransaction {
     readonly Connection: SqliteConnection | undefined;
+    readonly DbConnection: DbConnection | undefined;
     readonly IsolationLevel: IsolationLevel;
     readonly SupportsSavepoints: boolean;
     Commit(): void;
+    Dispose(disposing: boolean): void;
     Release(savepointName: string): void;
     Rollback(): void;
     Rollback(savepointName: string): void;
@@ -467,7 +481,6 @@ export interface SqliteTransaction$instance extends SqliteTransaction$protected,
 
 
 export const SqliteTransaction: {
-    new(): SqliteTransaction;
 };
 
 

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

@@ -16,6 +16,8 @@ import type { IRelationalDbContextOptionsBuilderInfrastructure, RelationalDbCont
 import type { DbContextOptionsBuilder } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.js";
 
 export interface SqliteDbContextOptionsBuilder$instance extends RelationalDbContextOptionsBuilder<SqliteDbContextOptionsBuilder, SqliteOptionsExtension> {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IRelationalDbContextOptionsBuilderInfrastructure: never;
+
 }
 
 

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

@@ -21,6 +21,8 @@ import type { ConventionSet, IConvention, IConventionContext, IEntityTypeAnnotat
 import type { IConventionAnnotation, IConventionProperty, IProperty, RuntimeProperty, StoreObjectIdentifier, ValueGenerated } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
 
 export interface SqliteConventionSetBuilder$instance extends RelationalConventionSetBuilder {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_Infrastructure_IProviderConventionSetBuilder: never;
+
     CreateConventionSet(): ConventionSet;
 }
 
@@ -34,12 +36,11 @@ export const SqliteConventionSetBuilder: {
 
 export type SqliteConventionSetBuilder = SqliteConventionSetBuilder$instance;
 
-export abstract class SqliteRuntimeModelConvention$protected {
-    protected ProcessPropertyAnnotations(annotations: Dictionary<System_Internal.String, unknown>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
-}
-
+export interface SqliteRuntimeModelConvention$instance extends RelationalRuntimeModelConvention {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizedConvention: never;
 
-export interface SqliteRuntimeModelConvention$instance extends SqliteRuntimeModelConvention$protected, RelationalRuntimeModelConvention {
+    ProcessPropertyAnnotations(annotations: Dictionary<System_Internal.String, unknown>, property: IProperty, runtimeProperty: RuntimeProperty, runtime: boolean): void;
 }
 
 
@@ -50,12 +51,11 @@ export const SqliteRuntimeModelConvention: {
 
 export type SqliteRuntimeModelConvention = SqliteRuntimeModelConvention$instance;
 
-export abstract class SqliteSharedTableConvention$protected {
-    protected readonly CheckConstraintsUniqueAcrossTables: boolean;
-}
-
+export interface SqliteSharedTableConvention$instance extends SharedTableConvention {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IConvention: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Conventions_IModelFinalizingConvention: never;
 
-export interface SqliteSharedTableConvention$instance extends SqliteSharedTableConvention$protected, SharedTableConvention {
+    readonly CheckConstraintsUniqueAcrossTables: boolean;
 }
 
 
@@ -66,13 +66,13 @@ export const SqliteSharedTableConvention: {
 
 export type SqliteSharedTableConvention = SqliteSharedTableConvention$instance;
 
-export abstract class SqliteStoreGenerationConvention$protected {
-    protected Validate(property: IConventionProperty, storeObject: StoreObjectIdentifier): void;
-}
-
+export interface SqliteStoreGenerationConvention$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 SqliteStoreGenerationConvention$instance extends SqliteStoreGenerationConvention$protected, StoreGenerationConvention {
     ProcessPropertyAnnotationChanged(propertyBuilder: IConventionPropertyBuilder, name: string, annotation: IConventionAnnotation, oldAnnotation: IConventionAnnotation, context: IConventionContext<IConventionAnnotation>): void;
+    Validate(property: IConventionProperty, storeObject: StoreObjectIdentifier): void;
 }
 
 
@@ -83,12 +83,18 @@ export const SqliteStoreGenerationConvention: {
 
 export type SqliteStoreGenerationConvention = SqliteStoreGenerationConvention$instance;
 
-export abstract class SqliteValueGenerationConvention$protected {
-    protected GetValueGenerated(property: IConventionProperty): Nullable<ValueGenerated>;
-}
-
-
-export interface SqliteValueGenerationConvention$instance extends SqliteValueGenerationConvention$protected, RelationalValueGenerationConvention {
+export interface SqliteValueGenerationConvention$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;
 }
 

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

@@ -14,39 +14,37 @@ import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efco
 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";
 
-export abstract class SqliteMigrationsSqlGenerator$protected {
-    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 CreateTableColumns(operation: CreateTableOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AlterDatabaseOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RenameIndexOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RenameTableOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RenameColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AddUniqueConstraintOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AddCheckConstraintOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: DropUniqueConstraintOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: DropCheckConstraintOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AlterColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: EnsureSchemaOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: DropSchemaOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RestartSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: CreateSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: RenameSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AlterSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: DropSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
-    protected Generate(operation: AddColumnOperation, model: IModel, builder: MigrationCommandListBuilder, terminate: boolean): void;
-    protected Generate(operation: DropIndexOperation, model: IModel, builder: MigrationCommandListBuilder, terminate: boolean): void;
-    protected Generate(operation: CreateTableOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: AddForeignKeyOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: AddPrimaryKeyOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: DropColumnOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: DropForeignKeyOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-    protected Generate(operation: DropPrimaryKeyOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
-}
-
+export interface SqliteMigrationsSqlGenerator$instance extends MigrationsSqlGenerator {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Migrations_IMigrationsSqlGenerator: never;
 
-export interface SqliteMigrationsSqlGenerator$instance extends SqliteMigrationsSqlGenerator$protected, MigrationsSqlGenerator {
+    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(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;
+    Generate(operation: RenameIndexOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: RenameTableOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: RenameColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: CreateTableOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: AddForeignKeyOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: AddPrimaryKeyOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: AddUniqueConstraintOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: AddCheckConstraintOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: DropColumnOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: DropForeignKeyOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: DropPrimaryKeyOperation, model: IModel, builder: MigrationCommandListBuilder, terminate?: boolean): void;
+    Generate(operation: DropUniqueConstraintOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: DropCheckConstraintOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: AlterColumnOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: EnsureSchemaOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: DropSchemaOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: RestartSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: CreateSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: RenameSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: AlterSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
+    Generate(operation: DropSequenceOperation, model: IModel, builder: MigrationCommandListBuilder): void;
 }
 
 

package/Microsoft.EntityFrameworkCore.Migrations.d.ts

@@ -15,3 +15,6 @@ import type { AddCheckConstraintOperation, AddColumnOperation, AddForeignKeyOper
 // Public API exports (curated - no internal $instance/$views leakage)
 export { SqliteMigrationBuilderExtensions$instance as SqliteMigrationBuilderExtensions } from './Microsoft.EntityFrameworkCore.Migrations/internal/index.js';
 export { SqliteMigrationsSqlGenerator as SqliteMigrationsSqlGenerator } from './Microsoft.EntityFrameworkCore.Migrations/internal/index.js';
+// Extension methods (C# using semantics)
+export type { ExtensionMethods_Microsoft_EntityFrameworkCore_Migrations as ExtensionMethods } from './__internal/extensions/index.js';
+

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

@@ -17,13 +17,11 @@ import type { IAnnotation } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.I
 import type { IColumn, IProperty, IRelationalModel } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
 import type { IServiceCollection } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection.js";
 
-export abstract class SqliteAnnotationCodeGenerator$protected {
-    protected IsHandledByConvention(property: IProperty, annotation: IAnnotation): boolean;
-}
-
+export interface SqliteAnnotationCodeGenerator$instance extends AnnotationCodeGenerator {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Design_IAnnotationCodeGenerator: never;
 
-export interface SqliteAnnotationCodeGenerator$instance extends SqliteAnnotationCodeGenerator$protected, AnnotationCodeGenerator {
     GenerateFluentApiCalls(property: IProperty, annotations: IDictionary<System_Internal.String, IAnnotation>): IReadOnlyList<MethodCallCodeFragment>;
+    IsHandledByConvention(property: IProperty, annotation: IAnnotation): boolean;
 }
 
 
@@ -49,6 +47,8 @@ export const SqliteCSharpRuntimeAnnotationCodeGenerator: {
 export type SqliteCSharpRuntimeAnnotationCodeGenerator = SqliteCSharpRuntimeAnnotationCodeGenerator$instance;
 
 export interface SqliteDesignTimeServices$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Design_IDesignTimeServices: never;
+
     ConfigureDesignTimeServices(serviceCollection: IServiceCollection): void;
 }
 

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

@@ -19,18 +19,16 @@ import type { DbLoggerCategory$Model$Validation } from "@tsonic/efcore/Microsoft
 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";
 
-export abstract class SqliteModelValidator$protected {
-    protected ValidateCompatible(property: IProperty, duplicateProperty: IProperty, columnName: string, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    protected ValidateNoSchemas(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    protected ValidateNoSequences(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    protected ValidateNoStoredProcedures(model: IModel, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    protected ValidateSharedTableCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-    protected ValidateValueGeneration(entityType: IEntityType, key: IKey, logger: IDiagnosticsLogger<DbLoggerCategory$Model$Validation>): void;
-}
-
+export interface SqliteModelValidator$instance extends RelationalModelValidator {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelValidator: never;
 
-export interface SqliteModelValidator$instance extends SqliteModelValidator$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;
+    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;
 }
 
 
@@ -41,22 +39,19 @@ export const SqliteModelValidator: {
 
 export type SqliteModelValidator = SqliteModelValidator$instance;
 
-export abstract class SqliteOptionsExtension$protected {
-    protected Clone(): RelationalOptionsExtension;
-}
-
+export interface SqliteOptionsExtension$instance extends RelationalOptionsExtension {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptionsExtension: never;
 
-export interface SqliteOptionsExtension$instance extends SqliteOptionsExtension$protected, RelationalOptionsExtension {
     readonly Info: DbContextOptionsExtensionInfo;
     readonly LoadSpatialite: boolean;
     ApplyServices(services: IServiceCollection): void;
+    Clone(): RelationalOptionsExtension;
     WithLoadSpatialite(loadSpatialite: boolean): SqliteOptionsExtension;
 }
 
 
 export const SqliteOptionsExtension: {
     new(): SqliteOptionsExtension;
-    new(copyFrom: SqliteOptionsExtension): SqliteOptionsExtension;
 };
 
 

package/Microsoft.EntityFrameworkCore.Sqlite.Internal.d.ts

@@ -16,3 +16,6 @@ import type { IEntityType, IKey, IReadOnlyProperty, IReadOnlySequence } from '@t
 export { SqliteLoggerExtensions$instance as SqliteLoggerExtensions } from './Microsoft.EntityFrameworkCore.Sqlite.Internal/internal/index.js';
 export { SqliteStrings$instance as SqliteStrings } from './Microsoft.EntityFrameworkCore.Sqlite.Internal/internal/index.js';
 export { SqliteResources$instance as SqliteResources } from './Microsoft.EntityFrameworkCore.Sqlite.Internal/internal/index.js';
+// Extension methods (C# using semantics)
+export type { ExtensionMethods_Microsoft_EntityFrameworkCore_Sqlite_Internal as ExtensionMethods } from './__internal/extensions/index.js';
+

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

@@ -14,6 +14,8 @@ import * as Microsoft_EntityFrameworkCore_Metadata_Internal from "@tsonic/efcore
 import type { IColumn, IRelationalAnnotationProvider, IRelationalModel, RelationalAnnotationProvider, RelationalAnnotationProviderDependencies } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Metadata.js";
 
 export interface SqliteAnnotationProvider$instance extends RelationalAnnotationProvider {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IRelationalAnnotationProvider: never;
+
     For(model: IRelationalModel, designTime: boolean): IEnumerable<IAnnotation>;
     For(column: IColumn, designTime: boolean): IEnumerable<IAnnotation>;
 }

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

@@ -14,21 +14,19 @@ import * as Microsoft_EntityFrameworkCore_Migrations_Internal from "@tsonic/efco
 import type { HistoryRepository, HistoryRepositoryDependencies, IHistoryRepository, IMigrationsDatabaseLock, LockReleaseBehavior } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Migrations.js";
 import type { IRelationalCommand, RelationalCommandParameterObject } from "@tsonic/efcore/Microsoft.EntityFrameworkCore.Storage.js";
 
-export abstract class SqliteHistoryRepository$protected {
-    protected readonly ExistsSql: string;
-    protected readonly LockTableName: string;
-    protected InterpretExistsResult(value: unknown): boolean;
-}
-
+export interface SqliteHistoryRepository$instance extends HistoryRepository {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Migrations_IHistoryRepository: never;
 
-export interface SqliteHistoryRepository$instance extends SqliteHistoryRepository$protected, HistoryRepository {
+    readonly ExistsSql: string;
     readonly LockReleaseBehavior: LockReleaseBehavior;
+    readonly LockTableName: string;
     AcquireDatabaseLock(): IMigrationsDatabaseLock;
     AcquireDatabaseLockAsync(cancellationToken?: CancellationToken): Task<IMigrationsDatabaseLock>;
     GetBeginIfExistsScript(migrationId: string): string;
     GetBeginIfNotExistsScript(migrationId: string): string;
     GetCreateIfNotExistsScript(): string;
     GetEndIfScript(): string;
+    InterpretExistsResult(value: unknown): boolean;
 }
 
 
@@ -40,6 +38,10 @@ export const SqliteHistoryRepository: {
 export type SqliteHistoryRepository = SqliteHistoryRepository$instance;
 
 export interface SqliteMigrationDatabaseLock$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Migrations_IMigrationsDatabaseLock: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly HistoryRepository: IHistoryRepository;
     Dispose(): void;
     DisposeAsync(): ValueTask;