@tsonic/efcore 10.0.2 → 10.0.5

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

@@ -46,6 +46,8 @@ export enum StoreTypePostfix {
 
 
 export interface IDatabase$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabase: never;
+
     CompileQuery<TResult>(query: Expression, async: boolean): Func<QueryContext, TResult>;
     CompileQueryExpression<TResult>(query: Expression, async: boolean): Expression<Func<QueryContext, TResult>>;
     SaveChanges(entries: IList<IUpdateEntry>): int;
@@ -56,6 +58,8 @@ export interface IDatabase$instance {
 export type IDatabase = IDatabase$instance;
 
 export interface IDatabaseCreator$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseCreator: never;
+
     EnsureDeleted(): boolean;
     EnsureDeletedAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
 }
@@ -64,6 +68,8 @@ export interface IDatabaseCreator$instance {
 export type IDatabaseCreator = IDatabaseCreator$instance;
 
 export interface IDatabaseFacadeDependencies$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseFacadeDependencies: never;
+
     readonly TransactionManager: IDbContextTransactionManager;
     readonly DatabaseCreator: IDatabaseCreator;
     readonly ExecutionStrategy: IExecutionStrategy;
@@ -81,6 +87,8 @@ export interface IDatabaseFacadeDependencies$instance {
 export type IDatabaseFacadeDependencies = IDatabaseFacadeDependencies$instance;
 
 export interface IDatabaseFacadeDependenciesAccessor$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseFacadeDependenciesAccessor: never;
+
     readonly Dependencies: IDatabaseFacadeDependencies;
     readonly Context: DbContext;
 }
@@ -89,6 +97,8 @@ export interface IDatabaseFacadeDependenciesAccessor$instance {
 export type IDatabaseFacadeDependenciesAccessor = IDatabaseFacadeDependenciesAccessor$instance;
 
 export interface IDatabaseProvider$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseProvider: never;
+
     readonly Name: string;
     readonly Version: string | undefined;
     IsConfigured(options: IDbContextOptions): boolean;
@@ -98,6 +108,8 @@ export interface IDatabaseProvider$instance {
 export type IDatabaseProvider = IDatabaseProvider$instance;
 
 export interface IDbContextTransaction$instance extends IDisposable, IAsyncDisposable {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDbContextTransaction: never;
+
     readonly TransactionId: Guid;
     readonly SupportsSavepoints: boolean;
     Commit(): void;
@@ -107,9 +119,13 @@ export interface IDbContextTransaction$instance extends IDisposable, IAsyncDispo
 }
 
 
+export interface IDbContextTransaction$instance extends System_Internal.IAsyncDisposable, System_Internal.IDisposable {}
+
 export type IDbContextTransaction = IDbContextTransaction$instance;
 
 export interface IDbContextTransactionManager$instance extends IResettableService {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDbContextTransactionManager: never;
+
     readonly CurrentTransaction: IDbContextTransaction | undefined;
     BeginTransaction(): IDbContextTransaction;
     BeginTransactionAsync(cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
@@ -125,6 +141,8 @@ export interface IDbContextTransactionManager$instance extends Microsoft_EntityF
 export type IDbContextTransactionManager = IDbContextTransactionManager$instance;
 
 export interface IExceptionDetector$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExceptionDetector: never;
+
     IsCancellation(exception: Exception, cancellationToken?: CancellationToken): boolean;
 }
 
@@ -132,6 +150,8 @@ export interface IExceptionDetector$instance {
 export type IExceptionDetector = IExceptionDetector$instance;
 
 export interface IExecutionStrategy$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategy: never;
+
     readonly RetriesOnFailure: boolean;
     Execute<TState, TResult>(state: TState, operation: Func<DbContext, TState, TResult>, verifySucceeded: Func<DbContext, TState, ExecutionResult_1<TResult>>): TResult;
     ExecuteAsync<TState, TResult>(state: TState, operation: Func<DbContext, TState, CancellationToken, Task<TResult>>, verifySucceeded: Func<DbContext, TState, CancellationToken, Task<ExecutionResult_1<TResult>>>, cancellationToken?: CancellationToken): Task<TResult>;
@@ -141,6 +161,8 @@ export interface IExecutionStrategy$instance {
 export type IExecutionStrategy = IExecutionStrategy$instance;
 
 export interface IExecutionStrategyFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategyFactory: never;
+
     Create(): IExecutionStrategy;
 }
 
@@ -148,6 +170,8 @@ export interface IExecutionStrategyFactory$instance {
 export type IExecutionStrategyFactory = IExecutionStrategyFactory$instance;
 
 export interface IParameterNameGeneratorFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IParameterNameGeneratorFactory: never;
+
     Create(): ParameterNameGenerator;
 }
 
@@ -155,6 +179,8 @@ export interface IParameterNameGeneratorFactory$instance {
 export type IParameterNameGeneratorFactory = IParameterNameGeneratorFactory$instance;
 
 export interface IRawSqlCommandBuilder$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRawSqlCommandBuilder: never;
+
     Build(sql: string, parameters: IEnumerable<unknown>, model: IModel): RawSqlCommand;
     Build(sql: string, parameters: IEnumerable<unknown>): RawSqlCommand;
     Build(sql: string): IRelationalCommand;
@@ -164,6 +190,8 @@ export interface IRawSqlCommandBuilder$instance {
 export type IRawSqlCommandBuilder = IRawSqlCommandBuilder$instance;
 
 export interface IRelationalCommand$instance extends IRelationalCommandTemplate {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommand: never;
+
     readonly CommandText: string;
     readonly LogCommandText: string;
     readonly Parameters: IReadOnlyList<IRelationalParameter>;
@@ -181,6 +209,8 @@ export interface IRelationalCommand$instance extends IRelationalCommandTemplate$
 export type IRelationalCommand = IRelationalCommand$instance;
 
 export interface IRelationalCommandBuilder$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilder: never;
+
     readonly Parameters: IReadOnlyList<IRelationalParameter>;
     readonly TypeMappingSource: IRelationalTypeMappingSource;
     readonly CommandTextLength: int;
@@ -196,6 +226,8 @@ export interface IRelationalCommandBuilder$instance {
 export type IRelationalCommandBuilder = IRelationalCommandBuilder$instance;
 
 export interface IRelationalCommandBuilderFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilderFactory: never;
+
     Create(): IRelationalCommandBuilder;
 }
 
@@ -203,6 +235,8 @@ export interface IRelationalCommandBuilderFactory$instance {
 export type IRelationalCommandBuilderFactory = IRelationalCommandBuilderFactory$instance;
 
 export interface IRelationalCommandTemplate$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandTemplate: never;
+
     readonly CommandText: string;
     readonly LogCommandText: string;
     readonly Parameters: IReadOnlyList<IRelationalParameter>;
@@ -213,8 +247,10 @@ export interface IRelationalCommandTemplate$instance {
 export type IRelationalCommandTemplate = IRelationalCommandTemplate$instance;
 
 export interface IRelationalConnection$instance extends IRelationalTransactionManager, IDbContextTransactionManager, IResettableService, IDisposable, IAsyncDisposable {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalConnection: never;
+
     get ConnectionString(): string | undefined;
-    set ConnectionString(value: string);
+    set ConnectionString(value: string | undefined);
     DbConnection: DbConnection;
     readonly Context: DbContext;
     readonly ConnectionId: Guid;
@@ -242,9 +278,13 @@ export interface IRelationalConnection$instance extends IRelationalTransactionMa
 }
 
 
+export interface IRelationalConnection$instance extends System_Internal.IAsyncDisposable, System_Internal.IDisposable {}
+
 export type IRelationalConnection = IRelationalConnection$instance;
 
 export interface IRelationalDatabaseCreator$instance extends IDatabaseCreator {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalDatabaseCreator: never;
+
     Create(): void;
     CreateAsync(cancellationToken?: CancellationToken): Task;
     Exists(): boolean;
@@ -260,6 +300,8 @@ export interface IRelationalDatabaseCreator$instance extends IDatabaseCreator$in
 export type IRelationalDatabaseCreator = IRelationalDatabaseCreator$instance;
 
 export interface IRelationalDatabaseFacadeDependencies$instance extends IDatabaseFacadeDependencies {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalDatabaseFacadeDependencies: never;
+
     readonly RelationalConnection: IRelationalConnection;
     readonly RawSqlCommandBuilder: IRawSqlCommandBuilder;
     readonly CommandLogger: IRelationalCommandDiagnosticsLogger;
@@ -279,6 +321,8 @@ export interface IRelationalDatabaseFacadeDependencies$instance extends IDatabas
 export type IRelationalDatabaseFacadeDependencies = IRelationalDatabaseFacadeDependencies$instance;
 
 export interface IRelationalParameter$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalParameter: never;
+
     readonly InvariantName: string;
     AddDbParameter(command: DbCommand, parameterValues: IReadOnlyDictionary<System_Internal.String, unknown>): void;
     AddDbParameter(command: DbCommand, value: unknown): void;
@@ -288,6 +332,8 @@ export interface IRelationalParameter$instance {
 export type IRelationalParameter = IRelationalParameter$instance;
 
 export interface IRelationalTransactionFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTransactionFactory: never;
+
     Create(connection: IRelationalConnection, transaction: DbTransaction, transactionId: Guid, logger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>, transactionOwned: boolean): RelationalTransaction;
 }
 
@@ -295,6 +341,8 @@ export interface IRelationalTransactionFactory$instance {
 export type IRelationalTransactionFactory = IRelationalTransactionFactory$instance;
 
 export interface IRelationalTransactionManager$instance extends IDbContextTransactionManager, IResettableService {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTransactionManager: never;
+
     readonly CurrentTransaction: IDbContextTransaction | undefined;
     BeginTransaction(): IDbContextTransaction;
     BeginTransaction(isolationLevel: IsolationLevel): IDbContextTransaction;
@@ -314,6 +362,8 @@ export interface IRelationalTransactionManager$instance extends IDbContextTransa
 export type IRelationalTransactionManager = IRelationalTransactionManager$instance;
 
 export interface IRelationalTypeMappingSource$instance extends ITypeMappingSource {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTypeMappingSource: never;
+
     FindMapping(elementType: IElementType): CoreTypeMapping | undefined;
     FindMapping(property: IProperty): CoreTypeMapping | undefined;
     FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | undefined;
@@ -332,6 +382,8 @@ export interface IRelationalTypeMappingSource$instance extends ITypeMappingSourc
 export type IRelationalTypeMappingSource = IRelationalTypeMappingSource$instance;
 
 export interface IRelationalTypeMappingSourcePlugin$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTypeMappingSourcePlugin: never;
+
     FindMapping(mappingInfo: RelationalTypeMappingInfo): RelationalTypeMapping | undefined;
 }
 
@@ -339,6 +391,8 @@ export interface IRelationalTypeMappingSourcePlugin$instance {
 export type IRelationalTypeMappingSourcePlugin = IRelationalTypeMappingSourcePlugin$instance;
 
 export interface ISqlGenerationHelper$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ISqlGenerationHelper: never;
+
     readonly StatementTerminator: string;
     readonly BatchTerminator: string;
     readonly StartTransactionStatement: string;
@@ -354,6 +408,8 @@ export interface ISqlGenerationHelper$instance {
 export type ISqlGenerationHelper = ISqlGenerationHelper$instance;
 
 export interface ITransactionEnlistmentManager$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITransactionEnlistmentManager: never;
+
     readonly CurrentAmbientTransaction: Transaction | undefined;
     readonly EnlistedTransaction: Transaction | undefined;
     EnlistTransaction(transaction: Transaction): void;
@@ -363,6 +419,8 @@ export interface ITransactionEnlistmentManager$instance {
 export type ITransactionEnlistmentManager = ITransactionEnlistmentManager$instance;
 
 export interface ITypeMappingSource$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSource: never;
+
     FindMapping(elementType: IElementType): CoreTypeMapping | undefined;
     FindMapping(property: IProperty): CoreTypeMapping | undefined;
     FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | undefined;
@@ -375,6 +433,8 @@ export interface ITypeMappingSource$instance {
 export type ITypeMappingSource = ITypeMappingSource$instance;
 
 export interface ITypeMappingSourcePlugin$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSourcePlugin: never;
+
     FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping | undefined;
 }
 
@@ -396,17 +456,19 @@ export const MaterializationContext: {
 export type MaterializationContext = MaterializationContext$instance;
 
 export interface RelationalCommandParameterObject$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly CommandSource: CommandSource;
     readonly Connection: IRelationalConnection;
-    readonly Context: DbContext;
+    readonly Context: DbContext | undefined;
     readonly DetailedErrorsEnabled: boolean;
-    readonly Logger: IRelationalCommandDiagnosticsLogger;
+    readonly Logger: IRelationalCommandDiagnosticsLogger | undefined;
     readonly ParameterValues: IReadOnlyDictionary<System_Internal.String, unknown | undefined> | undefined;
     readonly ReaderColumns: IReadOnlyList<ReaderColumn | undefined> | undefined;
     Equals(obj: unknown): boolean;
     Equals(other: RelationalCommandParameterObject): boolean;
     GetHashCode(): int;
-    ToString(): string | undefined;
+    ToString(): string;
 }
 
 
@@ -421,29 +483,32 @@ export const RelationalCommandParameterObject: {
 export type RelationalCommandParameterObject = RelationalCommandParameterObject$instance;
 
 export interface RelationalTypeMappingInfo$instance {
-    ClrType: Type;
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
+    get ClrType(): Type | undefined;
+    set ClrType(value: Type | undefined);
     readonly CoreTypeMappingInfo: TypeMappingInfo;
     DbType: Nullable<DbType>;
     get ElementTypeMapping(): RelationalTypeMapping | undefined;
-    set ElementTypeMapping(value: RelationalTypeMapping);
+    set ElementTypeMapping(value: RelationalTypeMapping | undefined);
     IsFixedLength: Nullable<System_Internal.Boolean>;
     IsKey: boolean;
     IsKeyOrIndex: boolean;
     IsRowVersion: Nullable<System_Internal.Boolean>;
     IsUnicode: Nullable<System_Internal.Boolean>;
     get JsonValueReaderWriter(): JsonValueReaderWriter | undefined;
-    set JsonValueReaderWriter(value: JsonValueReaderWriter);
+    set JsonValueReaderWriter(value: JsonValueReaderWriter | undefined);
     Precision: Nullable<System_Internal.Int32>;
     Scale: Nullable<System_Internal.Int32>;
     Size: Nullable<System_Internal.Int32>;
     get StoreTypeName(): string | undefined;
-    set StoreTypeName(value: string);
+    set StoreTypeName(value: string | undefined);
     get StoreTypeNameBase(): string | undefined;
-    set StoreTypeNameBase(value: string);
+    set StoreTypeNameBase(value: string | undefined);
     Equals(obj: unknown): boolean;
     Equals(other: RelationalTypeMappingInfo): boolean;
     GetHashCode(): int;
-    ToString(): string | undefined;
+    ToString(): string;
     WithConverter(converterInfo: ValueConverterInfo): RelationalTypeMappingInfo;
 }
 
@@ -463,22 +528,25 @@ export const RelationalTypeMappingInfo: {
 export type RelationalTypeMappingInfo = RelationalTypeMappingInfo$instance;
 
 export interface TypeMappingInfo$instance {
-    ClrType: Type;
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
+    get ClrType(): Type | undefined;
+    set ClrType(value: Type | undefined);
     get ElementTypeMapping(): CoreTypeMapping | undefined;
-    set ElementTypeMapping(value: CoreTypeMapping);
+    set ElementTypeMapping(value: CoreTypeMapping | undefined);
     IsKey: boolean;
     IsKeyOrIndex: boolean;
     IsRowVersion: Nullable<System_Internal.Boolean>;
     IsUnicode: Nullable<System_Internal.Boolean>;
     get JsonValueReaderWriter(): JsonValueReaderWriter | undefined;
-    set JsonValueReaderWriter(value: JsonValueReaderWriter);
+    set JsonValueReaderWriter(value: JsonValueReaderWriter | undefined);
     Precision: Nullable<System_Internal.Int32>;
     Scale: Nullable<System_Internal.Int32>;
     Size: Nullable<System_Internal.Int32>;
     Equals(obj: unknown): boolean;
     Equals(other: TypeMappingInfo): boolean;
     GetHashCode(): int;
-    ToString(): string | undefined;
+    ToString(): string;
     WithConverter(converterInfo: ValueConverterInfo): TypeMappingInfo;
 }
 
@@ -497,9 +565,11 @@ export const TypeMappingInfo: {
 export type TypeMappingInfo = TypeMappingInfo$instance;
 
 export interface ValueBuffer$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly Count: int;
     readonly IsEmpty: boolean;
-    Item: unknown;
+    [index: number]: unknown | undefined;
     Equals(obj: unknown): boolean;
     Equals(other: ValueBuffer): boolean;
     GetHashCode(): int;
@@ -514,127 +584,100 @@ export const ValueBuffer: {
 
 export type ValueBuffer = ValueBuffer$instance;
 
-export abstract class BoolTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-}
-
-
-export interface BoolTypeMapping$instance extends BoolTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface BoolTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+    GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
 export const BoolTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): BoolTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): BoolTypeMapping;
     readonly Default: BoolTypeMapping;
 };
 
 
 export type BoolTypeMapping = BoolTypeMapping$instance;
 
-export abstract class ByteArrayTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-}
-
-
-export interface ByteArrayTypeMapping$instance extends ByteArrayTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface ByteArrayTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+    GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
 export const ByteArrayTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>, size: Nullable<System_Internal.Int32>): ByteArrayTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): ByteArrayTypeMapping;
     readonly Default: ByteArrayTypeMapping;
 };
 
 
 export type ByteArrayTypeMapping = ByteArrayTypeMapping$instance;
 
-export abstract class ByteTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface ByteTypeMapping$instance extends ByteTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface ByteTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const ByteTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): ByteTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): ByteTypeMapping;
     readonly Default: ByteTypeMapping;
 };
 
 
 export type ByteTypeMapping = ByteTypeMapping$instance;
 
-export abstract class CharTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-}
-
-
-export interface CharTypeMapping$instance extends CharTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface CharTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+    GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
 export const CharTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): CharTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): CharTypeMapping;
     readonly Default: CharTypeMapping;
 };
 
 
 export type CharTypeMapping = CharTypeMapping$instance;
 
-export abstract class CoreTypeMapping$protected {
-    protected readonly Parameters: CoreTypeMapping_CoreTypeMappingParameters;
-    protected abstract Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface CoreTypeMapping$instance extends CoreTypeMapping$protected {
+export interface CoreTypeMapping$instance {
     readonly ClrType: Type;
     readonly Comparer: ValueComparer;
     readonly Converter: ValueConverter | undefined;
     readonly ElementTypeMapping: CoreTypeMapping | undefined;
     readonly JsonValueReaderWriter: JsonValueReaderWriter | undefined;
     readonly KeyComparer: ValueComparer;
+    readonly Parameters: unknown;
     readonly ProviderValueComparer: ValueComparer;
     readonly ValueGeneratorFactory: Func<IProperty, IEntityType, ValueGenerator> | undefined;
+    Clone(parameters: unknown): CoreTypeMapping;
     Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
     GenerateCodeLiteral(value: unknown): Expression;
     WithComposedConverter(converter: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
-export const CoreTypeMapping: {
-    new(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
+export const CoreTypeMapping: (abstract new(parameters: unknown) => CoreTypeMapping) & {
 };
 
 
 export type CoreTypeMapping = CoreTypeMapping$instance;
 
-export abstract class Database$protected {
-    protected readonly Dependencies: DatabaseDependencies;
-}
-
+export interface Database$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabase: never;
 
-export interface Database$instance extends Database$protected {
+    readonly Dependencies: DatabaseDependencies;
     CompileQuery<TResult>(query: Expression, async: boolean): Func<QueryContext, TResult>;
     CompileQueryExpression<TResult>(query: Expression, async: boolean): Expression<Func<QueryContext, TResult>>;
     SaveChanges(entries: IList<IUpdateEntry>): int;
@@ -642,8 +685,7 @@ export interface Database$instance extends Database$protected {
 }
 
 
-export const Database: {
-    new(dependencies: DatabaseDependencies): Database;
+export const Database: (abstract new(dependencies: DatabaseDependencies) => Database) & {
 };
 
 
@@ -657,6 +699,8 @@ export type Database = Database$instance & __Database$views;
 
 
 export interface DatabaseDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly Logger: IDiagnosticsLogger_1<DbLoggerCategory_Update>;
     QueryCompilationContextFactory: IQueryCompilationContextFactory;
     UpdateAdapterFactory: IUpdateAdapterFactory;
@@ -675,12 +719,10 @@ export const DatabaseDependencies: {
 
 export type DatabaseDependencies = DatabaseDependencies$instance;
 
-export abstract class DatabaseProvider_1$protected<TOptionsExtension extends IDbContextOptionsExtension> {
-    protected readonly Dependencies: DatabaseProviderDependencies;
-}
-
+export interface DatabaseProvider_1$instance<TOptionsExtension extends IDbContextOptionsExtension> {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseProvider: never;
 
-export interface DatabaseProvider_1$instance<TOptionsExtension extends IDbContextOptionsExtension> extends DatabaseProvider_1$protected<TOptionsExtension> {
+    readonly Dependencies: DatabaseProviderDependencies;
     readonly Name: string;
     readonly Version: string | undefined;
     IsConfigured(options: IDbContextOptions): boolean;
@@ -702,6 +744,8 @@ export type DatabaseProvider_1<TOptionsExtension extends IDbContextOptionsExtens
 
 
 export interface DatabaseProviderDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     _Clone_$(): DatabaseProviderDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: DatabaseProviderDependencies): boolean;
@@ -717,110 +761,85 @@ export const DatabaseProviderDependencies: {
 
 export type DatabaseProviderDependencies = DatabaseProviderDependencies$instance;
 
-export abstract class DateOnlyTypeMapping$protected {
-    protected readonly SqlLiteralFormatString: string;
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface DateOnlyTypeMapping$instance extends DateOnlyTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface DateOnlyTypeMapping$instance extends RelationalTypeMapping {
+    readonly SqlLiteralFormatString: string;
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const DateOnlyTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): DateOnlyTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): DateOnlyTypeMapping;
     readonly Default: DateOnlyTypeMapping;
 };
 
 
 export type DateOnlyTypeMapping = DateOnlyTypeMapping$instance;
 
-export abstract class DateTimeOffsetTypeMapping$protected {
-    protected readonly SqlLiteralFormatString: string;
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface DateTimeOffsetTypeMapping$instance extends DateTimeOffsetTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface DateTimeOffsetTypeMapping$instance extends RelationalTypeMapping {
+    readonly SqlLiteralFormatString: string;
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const DateTimeOffsetTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): DateTimeOffsetTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): DateTimeOffsetTypeMapping;
     readonly Default: DateTimeOffsetTypeMapping;
 };
 
 
 export type DateTimeOffsetTypeMapping = DateTimeOffsetTypeMapping$instance;
 
-export abstract class DateTimeTypeMapping$protected {
-    protected readonly SqlLiteralFormatString: string;
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface DateTimeTypeMapping$instance extends DateTimeTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface DateTimeTypeMapping$instance extends RelationalTypeMapping {
+    readonly SqlLiteralFormatString: string;
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const DateTimeTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): DateTimeTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): DateTimeTypeMapping;
     readonly Default: DateTimeTypeMapping;
 };
 
 
 export type DateTimeTypeMapping = DateTimeTypeMapping$instance;
 
-export abstract class DecimalTypeMapping$protected {
-    protected readonly SqlLiteralFormatString: string;
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface DecimalTypeMapping$instance extends DecimalTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface DecimalTypeMapping$instance extends RelationalTypeMapping {
+    readonly SqlLiteralFormatString: string;
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const DecimalTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): DecimalTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): DecimalTypeMapping;
     readonly Default: DecimalTypeMapping;
 };
 
 
 export type DecimalTypeMapping = DecimalTypeMapping$instance;
 
-export abstract class DoubleTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-}
-
-
-export interface DoubleTypeMapping$instance extends DoubleTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface DoubleTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+    GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
 export const DoubleTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): DoubleTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): DoubleTypeMapping;
     readonly Default: DoubleTypeMapping;
 };
 
@@ -840,34 +859,30 @@ export const ExecutionResult_1: {
 
 export type ExecutionResult_1<TResult> = ExecutionResult_1$instance<TResult>;
 
-export abstract class ExecutionStrategy$protected {
-    protected readonly Dependencies: ExecutionStrategyDependencies;
-    protected readonly ExceptionsEncountered: List<Exception>;
-    protected readonly Random: Random;
-    protected GetNextDelay(lastException: Exception): Nullable<TimeSpan>;
-    protected OnFirstExecution(): void;
-    protected OnRetry(): void;
-    protected abstract ShouldRetryOn(exception: Exception): boolean;
-    protected ShouldVerifySuccessOn(exception: Exception): boolean;
-}
-
+export interface ExecutionStrategy$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategy: never;
 
-export interface ExecutionStrategy$instance extends ExecutionStrategy$protected {
+    readonly Dependencies: ExecutionStrategyDependencies;
+    readonly ExceptionsEncountered: List<Exception>;
     readonly MaxRetryCount: int;
     readonly MaxRetryDelay: TimeSpan;
+    readonly Random: Random;
     readonly RetriesOnFailure: boolean;
     Execute<TState, TResult>(state: TState, operation: Func<DbContext, TState, TResult>, verifySucceeded: Func<DbContext, TState, ExecutionResult_1<TResult>>): TResult;
     ExecuteAsync<TState, TResult>(state: TState, operation: Func<DbContext, TState, CancellationToken, Task<TResult>>, verifySucceeded: Func<DbContext, TState, CancellationToken, Task<ExecutionResult_1<TResult>>>, cancellationToken?: CancellationToken): Task<TResult>;
+    GetNextDelay(lastException: Exception): Nullable<TimeSpan>;
+    OnFirstExecution(): void;
+    OnRetry(): void;
+    ShouldRetryOn(exception: Exception): boolean;
+    ShouldVerifySuccessOn(exception: Exception): boolean;
 }
 
 
-export const ExecutionStrategy: {
-    new(context: DbContext, maxRetryCount: int, maxRetryDelay: TimeSpan): ExecutionStrategy;
-    new(dependencies: ExecutionStrategyDependencies, maxRetryCount: int, maxRetryDelay: TimeSpan): ExecutionStrategy;
+export const ExecutionStrategy: (abstract new(context: DbContext, maxRetryCount: int, maxRetryDelay: TimeSpan) => ExecutionStrategy) & (abstract new(dependencies: ExecutionStrategyDependencies, maxRetryCount: int, maxRetryDelay: TimeSpan) => ExecutionStrategy) & {
     readonly DefaultMaxRetryCount: int;
     readonly DefaultMaxDelay: TimeSpan;
     get Current(): ExecutionStrategy | undefined;
-    set Current(value: ExecutionStrategy);
+    set Current(value: ExecutionStrategy | undefined);
     CallOnWrappedException<TResult>(exception: Exception, exceptionHandler: Func<Exception, TResult>): TResult;
 };
 
@@ -882,6 +897,8 @@ export type ExecutionStrategy = ExecutionStrategy$instance & __ExecutionStrategy
 
 
 export interface ExecutionStrategyDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     CurrentContext: ICurrentDbContext;
     Logger: IDiagnosticsLogger_1<DbLoggerCategory_Infrastructure>;
     Options: IDbContextOptions;
@@ -900,83 +917,62 @@ export const ExecutionStrategyDependencies: {
 
 export type ExecutionStrategyDependencies = ExecutionStrategyDependencies$instance;
 
-export abstract class FloatTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-}
-
-
-export interface FloatTypeMapping$instance extends FloatTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface FloatTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+    GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
 export const FloatTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): FloatTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): FloatTypeMapping;
     readonly Default: FloatTypeMapping;
 };
 
 
 export type FloatTypeMapping = FloatTypeMapping$instance;
 
-export abstract class GuidTypeMapping$protected {
-    protected readonly SqlLiteralFormatString: string;
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface GuidTypeMapping$instance extends GuidTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface GuidTypeMapping$instance extends RelationalTypeMapping {
+    readonly SqlLiteralFormatString: string;
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const GuidTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): GuidTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): GuidTypeMapping;
     readonly Default: GuidTypeMapping;
 };
 
 
 export type GuidTypeMapping = GuidTypeMapping$instance;
 
-export abstract class IntTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface IntTypeMapping$instance extends IntTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface IntTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const IntTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): IntTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): IntTypeMapping;
     readonly Default: IntTypeMapping;
 };
 
 
 export type IntTypeMapping = IntTypeMapping$instance;
 
-export abstract class JsonTypeMapping$protected {
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-}
-
-
-export interface JsonTypeMapping$instance extends JsonTypeMapping$protected, RelationalTypeMapping {
+export interface JsonTypeMapping$instance extends RelationalTypeMapping {
+    GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
-export const JsonTypeMapping: {
-    new(storeType: string, clrType: Type, dbType: Nullable<DbType>): JsonTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): JsonTypeMapping;
+export const JsonTypeMapping: (abstract new(storeType: string, clrType: Type, dbType: Nullable<DbType>) => JsonTypeMapping) & (abstract new(parameters: unknown) => JsonTypeMapping) & {
 };
 
 
@@ -987,27 +983,21 @@ export interface JsonTypePlaceholder$instance {
 
 
 export const JsonTypePlaceholder: {
-    new(): JsonTypePlaceholder;
 };
 
 
 export type JsonTypePlaceholder = JsonTypePlaceholder$instance;
 
-export abstract class LongTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface LongTypeMapping$instance extends LongTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface LongTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const LongTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): LongTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): LongTypeMapping;
     readonly Default: LongTypeMapping;
 };
 
@@ -1015,6 +1005,8 @@ export const LongTypeMapping: {
 export type LongTypeMapping = LongTypeMapping$instance;
 
 export interface NonRetryingExecutionStrategy$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategy: never;
+
     readonly RetriesOnFailure: boolean;
     Execute<TState, TResult>(state: TState, operation: Func<DbContext, TState, TResult>, verifySucceeded: Func<DbContext, TState, ExecutionResult_1<TResult>>): TResult;
     ExecuteAsync<TState, TResult>(state: TState, operation: Func<DbContext, TState, CancellationToken, Task<TResult>>, verifySucceeded: Func<DbContext, TState, CancellationToken, Task<ExecutionResult_1<TResult>>>, cancellationToken?: CancellationToken): Task<TResult>;
@@ -1050,6 +1042,8 @@ export const ParameterNameGenerator: {
 export type ParameterNameGenerator = ParameterNameGenerator$instance;
 
 export interface ParameterNameGeneratorDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     _Clone_$(): ParameterNameGeneratorDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: ParameterNameGeneratorDependencies): boolean;
@@ -1065,12 +1059,10 @@ export const ParameterNameGeneratorDependencies: {
 
 export type ParameterNameGeneratorDependencies = ParameterNameGeneratorDependencies$instance;
 
-export abstract class ParameterNameGeneratorFactory$protected {
-    protected readonly Dependencies: ParameterNameGeneratorDependencies;
-}
-
+export interface ParameterNameGeneratorFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IParameterNameGeneratorFactory: never;
 
-export interface ParameterNameGeneratorFactory$instance extends ParameterNameGeneratorFactory$protected {
+    readonly Dependencies: ParameterNameGeneratorDependencies;
     Create(): ParameterNameGenerator;
 }
 
@@ -1105,14 +1097,13 @@ export type RawSqlCommand = RawSqlCommand$instance;
 export interface ReaderColumn$instance {
     readonly GetFieldValueExpression: LambdaExpression;
     readonly IsNullable: boolean;
-    readonly Name: string;
-    readonly Property: IPropertyBase;
+    readonly Name: string | undefined;
+    readonly Property: IPropertyBase | undefined;
     readonly Type: Type;
 }
 
 
-export const ReaderColumn: {
-    new(type: Type, nullable: boolean, name: string, property: IPropertyBase, getFieldValueExpression: LambdaExpression): ReaderColumn;
+export const ReaderColumn: (abstract new(type: Type, nullable: boolean, name: string, property: IPropertyBase, getFieldValueExpression: LambdaExpression) => ReaderColumn) & {
     Create(type: Type, nullable: boolean, columnName: string, property: IPropertyBase, readFunc: LambdaExpression): ReaderColumn;
     GetConstructor(type: Type): ConstructorInfo;
 };
@@ -1132,17 +1123,16 @@ export const ReaderColumn_1: {
 
 export type ReaderColumn_1<T> = ReaderColumn_1$instance<T>;
 
-export abstract class RelationalCommand$protected {
-    protected readonly Dependencies: RelationalCommandBuilderDependencies;
-    protected CreateRelationalDataReader(): RelationalDataReader;
-}
+export interface RelationalCommand$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommand: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandTemplate: never;
 
-
-export interface RelationalCommand$instance extends RelationalCommand$protected {
     CommandText: string;
+    readonly Dependencies: RelationalCommandBuilderDependencies;
     LogCommandText: string;
     Parameters: IReadOnlyList<IRelationalParameter>;
     CreateDbCommand(parameterObject: RelationalCommandParameterObject, commandId: Guid, commandMethod: DbCommandMethod): DbCommand;
+    CreateRelationalDataReader(): RelationalDataReader;
     ExecuteNonQuery(parameterObject: RelationalCommandParameterObject): int;
     ExecuteNonQueryAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
     ExecuteReader(parameterObject: RelationalCommandParameterObject): RelationalDataReader;
@@ -1166,13 +1156,11 @@ export interface __RelationalCommand$views {
 export type RelationalCommand = RelationalCommand$instance & __RelationalCommand$views;
 
 
-export abstract class RelationalCommandBuilder$protected {
-    protected readonly Dependencies: RelationalCommandBuilderDependencies;
-}
-
+export interface RelationalCommandBuilder$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilder: never;
 
-export interface RelationalCommandBuilder$instance extends RelationalCommandBuilder$protected {
     readonly CommandTextLength: int;
+    readonly Dependencies: RelationalCommandBuilderDependencies;
     readonly Parameters: IReadOnlyList<IRelationalParameter>;
     readonly TypeMappingSource: IRelationalTypeMappingSource;
     AddParameter(parameter: IRelationalParameter): IRelationalCommandBuilder;
@@ -1200,6 +1188,8 @@ export type RelationalCommandBuilder = RelationalCommandBuilder$instance & __Rel
 
 
 export interface RelationalCommandBuilderDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     ExceptionDetector: IExceptionDetector;
     LoggingOptions: ILoggingOptions;
     TypeMappingSource: IRelationalTypeMappingSource;
@@ -1218,12 +1208,10 @@ export const RelationalCommandBuilderDependencies: {
 
 export type RelationalCommandBuilderDependencies = RelationalCommandBuilderDependencies$instance;
 
-export abstract class RelationalCommandBuilderFactory$protected {
-    protected readonly Dependencies: RelationalCommandBuilderDependencies;
-}
-
+export interface RelationalCommandBuilderFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilderFactory: never;
 
-export interface RelationalCommandBuilderFactory$instance extends RelationalCommandBuilderFactory$protected {
+    readonly Dependencies: RelationalCommandBuilderDependencies;
     Create(): IRelationalCommandBuilder;
 }
 
@@ -1242,51 +1230,55 @@ export interface RelationalCommandBuilderFactory$instance extends IRelationalCom
 export type RelationalCommandBuilderFactory = RelationalCommandBuilderFactory$instance & __RelationalCommandBuilderFactory$views;
 
 
-export abstract class RelationalConnection$protected {
-    protected readonly Dependencies: RelationalConnectionDependencies;
-    protected readonly SupportsAmbientTransactions: boolean;
-    protected CloseDbConnection(): void;
-    protected CloseDbConnectionAsync(): Task;
-    protected ConnectionBeginTransaction(isolationLevel: IsolationLevel): DbTransaction;
-    protected ConnectionBeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): ValueTask<DbTransaction>;
-    protected ConnectionEnlistTransaction(transaction: Transaction): void;
-    protected abstract CreateDbConnection(): DbConnection;
-    protected DisposeDbConnection(): void;
-    protected DisposeDbConnectionAsync(): ValueTask;
-    protected GetValidatedConnectionString(): string;
-    protected OpenDbConnection(errorsExpected: boolean): void;
-    protected OpenDbConnectionAsync(errorsExpected: boolean, cancellationToken: CancellationToken): Task;
-    protected ResetState(disposeDbConnection: boolean): void;
-    protected ResetStateAsync(disposeDbConnection: boolean): ValueTask;
-}
-
+export interface RelationalConnection$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IResettableService: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDbContextTransactionManager: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalConnection: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTransactionManager: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITransactionEnlistmentManager: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface RelationalConnection$instance extends RelationalConnection$protected {
     CommandTimeout: Nullable<System_Internal.Int32>;
     readonly ConnectionId: Guid;
     get ConnectionString(): string | undefined;
-    set ConnectionString(value: string);
+    set ConnectionString(value: string | undefined);
     readonly Context: DbContext;
     readonly CurrentAmbientTransaction: Transaction | undefined;
     get CurrentTransaction(): IDbContextTransaction | undefined;
-    set CurrentTransaction(value: IDbContextTransaction);
+    set CurrentTransaction(value: IDbContextTransaction | undefined);
     DbConnection: DbConnection;
+    readonly Dependencies: RelationalConnectionDependencies;
     get EnlistedTransaction(): Transaction | undefined;
-    set EnlistedTransaction(value: Transaction);
+    set EnlistedTransaction(value: Transaction | undefined);
+    readonly SupportsAmbientTransactions: boolean;
     BeginTransaction(): IDbContextTransaction;
     BeginTransaction(isolationLevel: IsolationLevel): IDbContextTransaction;
     BeginTransactionAsync(cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
     BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
     Close(): boolean;
     CloseAsync(): Task<System_Internal.Boolean>;
+    CloseDbConnection(): void;
+    CloseDbConnectionAsync(): Task;
     CommitTransaction(): void;
     CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
+    ConnectionBeginTransaction(isolationLevel: IsolationLevel): DbTransaction;
+    ConnectionBeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): ValueTask<DbTransaction>;
+    ConnectionEnlistTransaction(transaction: Transaction): void;
+    CreateDbConnection(): DbConnection;
     Dispose(): void;
     DisposeAsync(): ValueTask;
+    DisposeDbConnection(): void;
+    DisposeDbConnectionAsync(): ValueTask;
     EnlistTransaction(transaction: Transaction): void;
+    GetValidatedConnectionString(): string;
     Open(errorsExpected?: boolean): boolean;
     OpenAsync(cancellationToken: CancellationToken, errorsExpected?: boolean): Task<System_Internal.Boolean>;
+    OpenDbConnection(errorsExpected: boolean): void;
+    OpenDbConnectionAsync(errorsExpected: boolean, cancellationToken: CancellationToken): Task;
     RentCommand(): IRelationalCommand;
+    ResetState(disposeDbConnection: boolean): void;
+    ResetStateAsync(disposeDbConnection: boolean): ValueTask;
     ReturnCommand(command: IRelationalCommand): void;
     RollbackTransaction(): void;
     RollbackTransactionAsync(cancellationToken?: CancellationToken): Task;
@@ -1298,8 +1290,7 @@ export interface RelationalConnection$instance extends RelationalConnection$prot
 }
 
 
-export const RelationalConnection: {
-    new(dependencies: RelationalConnectionDependencies): RelationalConnection;
+export const RelationalConnection: (abstract new(dependencies: RelationalConnectionDependencies) => RelationalConnection) & {
 };
 
 
@@ -1315,6 +1306,8 @@ export type RelationalConnection = RelationalConnection$instance & __RelationalC
 
 
 export interface RelationalConnectionDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     ConnectionLogger: IRelationalConnectionDiagnosticsLogger;
     ConnectionStringResolver: INamedConnectionStringResolver;
     ContextOptions: IDbContextOptions;
@@ -1338,12 +1331,10 @@ export const RelationalConnectionDependencies: {
 
 export type RelationalConnectionDependencies = RelationalConnectionDependencies$instance;
 
-export abstract class RelationalDatabase$protected {
-    protected readonly RelationalDependencies: RelationalDatabaseDependencies;
-}
-
+export interface RelationalDatabase$instance extends Database$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabase: never;
 
-export interface RelationalDatabase$instance extends RelationalDatabase$protected, Database$instance {
+    readonly RelationalDependencies: RelationalDatabaseDependencies;
     CompileQuery<TResult>(query: Expression, async: boolean): Func<QueryContext, TResult>;
     CompileQueryExpression<TResult>(query: Expression, async: boolean): Expression<Func<QueryContext, TResult>>;
     SaveChanges(entries: IList<IUpdateEntry>): int;
@@ -1363,13 +1354,11 @@ export interface __RelationalDatabase$views {
 export type RelationalDatabase = RelationalDatabase$instance & __RelationalDatabase$views;
 
 
-export abstract class RelationalDatabaseCreator$protected {
-    protected readonly Dependencies: RelationalDatabaseCreatorDependencies;
-    protected GetCreateTablesCommands(options?: MigrationsSqlGenerationOptions): IReadOnlyList<MigrationCommand>;
-}
-
+export interface RelationalDatabaseCreator$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseCreator: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalDatabaseCreator: never;
 
-export interface RelationalDatabaseCreator$instance extends RelationalDatabaseCreator$protected {
+    readonly Dependencies: RelationalDatabaseCreatorDependencies;
     CanConnect(): boolean;
     CanConnectAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
     Create(): void;
@@ -1385,13 +1374,13 @@ export interface RelationalDatabaseCreator$instance extends RelationalDatabaseCr
     Exists(): boolean;
     ExistsAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
     GenerateCreateScript(): string;
+    GetCreateTablesCommands(options?: MigrationsSqlGenerationOptions): IReadOnlyList<MigrationCommand>;
     HasTables(): boolean;
     HasTablesAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
 }
 
 
-export const RelationalDatabaseCreator: {
-    new(dependencies: RelationalDatabaseCreatorDependencies): RelationalDatabaseCreator;
+export const RelationalDatabaseCreator: (abstract new(dependencies: RelationalDatabaseCreatorDependencies) => RelationalDatabaseCreator) & {
 };
 
 
@@ -1406,6 +1395,8 @@ export type RelationalDatabaseCreator = RelationalDatabaseCreator$instance & __R
 
 
 export interface RelationalDatabaseCreatorDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     CommandLogger: IRelationalCommandDiagnosticsLogger;
     Connection: IRelationalConnection;
     ContextOptions: IDbContextOptions;
@@ -1432,6 +1423,8 @@ export const RelationalDatabaseCreatorDependencies: {
 export type RelationalDatabaseCreatorDependencies = RelationalDatabaseCreatorDependencies$instance;
 
 export interface RelationalDatabaseDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     BatchExecutor: IBatchExecutor;
     BatchPreparer: ICommandBatchPreparer;
     Connection: IRelationalConnection;
@@ -1451,6 +1444,9 @@ export const RelationalDatabaseDependencies: {
 export type RelationalDatabaseDependencies = RelationalDatabaseDependencies$instance;
 
 export interface RelationalDataReader$instance {
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly CommandId: Guid;
     readonly DbCommand: DbCommand;
     readonly DbDataReader: DbDataReader;
@@ -1472,14 +1468,12 @@ export const RelationalDataReader: {
 
 export type RelationalDataReader = RelationalDataReader$instance;
 
-export abstract class RelationalExecutionStrategyFactory$protected {
-    protected readonly Dependencies: ExecutionStrategyDependencies;
-    protected CreateDefaultStrategy(dependencies: ExecutionStrategyDependencies): IExecutionStrategy;
-}
-
+export interface RelationalExecutionStrategyFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategyFactory: never;
 
-export interface RelationalExecutionStrategyFactory$instance extends RelationalExecutionStrategyFactory$protected {
+    readonly Dependencies: ExecutionStrategyDependencies;
     Create(): IExecutionStrategy;
+    CreateDefaultStrategy(dependencies: ExecutionStrategyDependencies): IExecutionStrategy;
 }
 
 
@@ -1497,38 +1491,30 @@ export interface RelationalExecutionStrategyFactory$instance extends IExecutionS
 export type RelationalExecutionStrategyFactory = RelationalExecutionStrategyFactory$instance & __RelationalExecutionStrategyFactory$views;
 
 
-export abstract class RelationalGeometryTypeMapping_2$protected<TGeometry, TProvider> {
-    protected readonly SpatialConverter: ValueConverter_2<TGeometry, TProvider> | undefined;
-    protected readonly WktReaderType: Type;
-    protected abstract AsText(value: unknown): string;
-    protected abstract GetSrid(value: unknown): int;
-}
-
-
-export interface RelationalGeometryTypeMapping_2$instance<TGeometry, TProvider> extends RelationalGeometryTypeMapping_2$protected<TGeometry, TProvider>, RelationalTypeMapping {
+export interface RelationalGeometryTypeMapping_2$instance<TGeometry, TProvider> extends RelationalTypeMapping {
+    readonly SpatialConverter: ValueConverter_2<TGeometry, TProvider> | undefined;
+    readonly WktReaderType: Type;
+    AsText(value: unknown): string;
     CreateParameter(command: DbCommand, name: string, value: unknown, nullable?: Nullable<System_Internal.Boolean>, direction?: ParameterDirection): DbParameter;
     CreateParameter(command: DbCommand, name: string, value: unknown, nullable?: Nullable<System_Internal.Boolean>, direction?: ParameterDirection): DbParameter;
     CustomizeDataReaderExpression(expression: Expression): Expression;
     GenerateCodeLiteral(value: unknown): Expression;
+    GetSrid(value: unknown): int;
 }
 
 
-export const RelationalGeometryTypeMapping_2: {
-    new<TGeometry, TProvider>(converter: ValueConverter_2<TGeometry, TProvider>, storeType: string, jsonValueReaderWriter: JsonValueReaderWriter): RelationalGeometryTypeMapping_2<TGeometry, TProvider>;
-    new<TGeometry, TProvider>(parameters: RelationalTypeMapping_RelationalTypeMappingParameters, converter: ValueConverter_2<TGeometry, TProvider>): RelationalGeometryTypeMapping_2<TGeometry, TProvider>;
+export const RelationalGeometryTypeMapping_2: (abstract new<TGeometry, TProvider>(converter: ValueConverter_2<TGeometry, TProvider>, storeType: string, jsonValueReaderWriter: JsonValueReaderWriter) => RelationalGeometryTypeMapping_2<TGeometry, TProvider>) & (abstract new<TGeometry, TProvider>(parameters: unknown, converter: ValueConverter_2<TGeometry, TProvider>) => RelationalGeometryTypeMapping_2<TGeometry, TProvider>) & {
 };
 
 
 export type RelationalGeometryTypeMapping_2<TGeometry, TProvider> = RelationalGeometryTypeMapping_2$instance<TGeometry, TProvider>;
 
-export abstract class RelationalSqlGenerationHelper$protected {
-    protected readonly Dependencies: RelationalSqlGenerationHelperDependencies;
-}
-
+export interface RelationalSqlGenerationHelper$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ISqlGenerationHelper: never;
 
-export interface RelationalSqlGenerationHelper$instance extends RelationalSqlGenerationHelper$protected {
     readonly BatchTerminator: string;
     readonly CommitTransactionStatement: string;
+    readonly Dependencies: RelationalSqlGenerationHelperDependencies;
     readonly SingleLineCommentToken: string;
     readonly StartTransactionStatement: string;
     readonly StatementTerminator: string;
@@ -1564,6 +1550,8 @@ export type RelationalSqlGenerationHelper = RelationalSqlGenerationHelper$instan
 
 
 export interface RelationalSqlGenerationHelperDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     _Clone_$(): RelationalSqlGenerationHelperDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: RelationalSqlGenerationHelperDependencies): boolean;
@@ -1579,17 +1567,18 @@ export const RelationalSqlGenerationHelperDependencies: {
 
 export type RelationalSqlGenerationHelperDependencies = RelationalSqlGenerationHelperDependencies$instance;
 
-export abstract class RelationalTransaction$protected {
-    protected readonly Connection: IRelationalConnection;
-    protected readonly Logger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>;
-    protected ClearTransaction(): void;
-    protected ClearTransactionAsync(cancellationToken?: CancellationToken): Task;
-}
-
+export interface RelationalTransaction$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IInfrastructure_1: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDbContextTransaction: never;
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
 
-export interface RelationalTransaction$instance extends RelationalTransaction$protected {
+    readonly Connection: IRelationalConnection;
+    readonly Logger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>;
     readonly SupportsSavepoints: boolean;
     readonly TransactionId: Guid;
+    ClearTransaction(): void;
+    ClearTransactionAsync(cancellationToken?: CancellationToken): Task;
     Commit(): void;
     CommitAsync(cancellationToken?: CancellationToken): Task;
     CreateSavepoint(name: string): void;
@@ -1620,12 +1609,10 @@ export interface RelationalTransaction$instance extends Microsoft_EntityFramewor
 export type RelationalTransaction = RelationalTransaction$instance & __RelationalTransaction$views;
 
 
-export abstract class RelationalTransactionFactory$protected {
-    protected readonly Dependencies: RelationalTransactionFactoryDependencies;
-}
-
+export interface RelationalTransactionFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTransactionFactory: never;
 
-export interface RelationalTransactionFactory$instance extends RelationalTransactionFactory$protected {
+    readonly Dependencies: RelationalTransactionFactoryDependencies;
     Create(connection: IRelationalConnection, transaction: DbTransaction, transactionId: Guid, logger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>, transactionOwned: boolean): RelationalTransaction;
 }
 
@@ -1645,6 +1632,8 @@ export type RelationalTransactionFactory = RelationalTransactionFactory$instance
 
 
 export interface RelationalTransactionFactoryDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     SqlGenerationHelper: ISqlGenerationHelper;
     _Clone_$(): RelationalTransactionFactoryDependencies;
     Equals(obj: unknown): boolean;
@@ -1661,34 +1650,30 @@ export const RelationalTransactionFactoryDependencies: {
 
 export type RelationalTransactionFactoryDependencies = RelationalTransactionFactoryDependencies$instance;
 
-export abstract class RelationalTypeMapping$protected {
-    protected readonly Parameters: RelationalTypeMapping_RelationalTypeMappingParameters;
-    protected readonly SqlLiteralFormatString: string;
-    protected Clone2(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-    protected abstract Clone2(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected ConfigureParameter(parameter: DbParameter): void;
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-    protected ProcessStoreType(parameters: RelationalTypeMapping_RelationalTypeMappingParameters, storeType: string, storeTypeNameBase: string): string;
-}
-
-
-export interface RelationalTypeMapping$instance extends RelationalTypeMapping$protected, CoreTypeMapping {
+export interface RelationalTypeMapping$instance extends CoreTypeMapping {
     readonly DbType: Nullable<DbType>;
     readonly IsFixedLength: boolean;
     readonly IsUnicode: boolean;
+    readonly Parameters: unknown;
     readonly Precision: Nullable<System_Internal.Int32>;
     readonly Scale: Nullable<System_Internal.Int32>;
     readonly Size: Nullable<System_Internal.Int32>;
+    readonly SqlLiteralFormatString: string;
     readonly StoreType: string;
     readonly StoreTypeNameBase: string;
     readonly StoreTypePostfix: StoreTypePostfix;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(parameters: unknown): RelationalTypeMapping;
     Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
     Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+    ConfigureParameter(parameter: DbParameter): void;
     CreateParameter(command: DbCommand, name: string, value: unknown, nullable?: Nullable<System_Internal.Boolean>, direction?: ParameterDirection): DbParameter;
     CustomizeDataReaderExpression(expression: Expression): Expression;
+    GenerateNonNullSqlLiteral(value: unknown): string;
     GenerateProviderValueSqlLiteral(value: unknown): string;
     GenerateSqlLiteral(value: unknown): string;
     GetDataReaderMethod(): MethodInfo;
+    ProcessStoreType(parameters: unknown, storeType: string, storeTypeNameBase: string): string;
     WithComposedConverter(converter: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
     WithPrecisionAndScale(precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): RelationalTypeMapping;
     WithStoreTypeAndSize(storeType: string, size: Nullable<System_Internal.Int32>): RelationalTypeMapping;
@@ -1696,9 +1681,7 @@ export interface RelationalTypeMapping$instance extends RelationalTypeMapping$pr
 }
 
 
-export const RelationalTypeMapping: {
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    new(storeType: string, clrType: Type, dbType: Nullable<DbType>, unicode: boolean, size: Nullable<System_Internal.Int32>, fixedLength: boolean, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>, jsonValueReaderWriter: JsonValueReaderWriter): RelationalTypeMapping;
+export const RelationalTypeMapping: (abstract new(parameters: unknown) => RelationalTypeMapping) & (abstract new(storeType: string, clrType: Type, dbType: Nullable<DbType>, unicode: boolean, size: Nullable<System_Internal.Int32>, fixedLength: boolean, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>, jsonValueReaderWriter: JsonValueReaderWriter) => RelationalTypeMapping) & {
     readonly NullMapping: RelationalTypeMapping;
     GetDataReaderMethod(type: Type): MethodInfo;
 };
@@ -1706,16 +1689,14 @@ export const RelationalTypeMapping: {
 
 export type RelationalTypeMapping = RelationalTypeMapping$instance;
 
-export abstract class RelationalTypeMappingSource$protected {
-    protected readonly RelationalDependencies: RelationalTypeMappingSourceDependencies;
-    protected FindCollectionMapping(info: RelationalTypeMappingInfo, modelType: Type, providerType: Type, elementMapping: CoreTypeMapping): RelationalTypeMapping | undefined;
-    protected FindMapping8(mappingInfo: RelationalTypeMappingInfo): RelationalTypeMapping | undefined;
-    protected FindMapping8(mappingInfo: TypeMappingInfo): CoreTypeMapping;
-    protected ParseStoreTypeName(storeTypeName: string, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): string | undefined;
-}
-
+export interface RelationalTypeMappingSource$instance extends TypeMappingSourceBase$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTypeMappingSource: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSource: never;
 
-export interface RelationalTypeMappingSource$instance extends RelationalTypeMappingSource$protected, TypeMappingSourceBase$instance {
+    readonly RelationalDependencies: RelationalTypeMappingSourceDependencies;
+    FindCollectionMapping(info: RelationalTypeMappingInfo, modelType: Type, providerType: Type, elementMapping: CoreTypeMapping): RelationalTypeMapping | undefined;
+    FindMapping(mappingInfo: RelationalTypeMappingInfo): RelationalTypeMapping | undefined;
+    FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping;
     FindMapping(property: IProperty): CoreTypeMapping | undefined;
     FindMapping(elementType: IElementType): CoreTypeMapping | undefined;
     FindMapping(type: Type): RelationalTypeMapping | undefined;
@@ -1726,11 +1707,11 @@ export interface RelationalTypeMappingSource$instance extends RelationalTypeMapp
     FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping): CoreTypeMapping | undefined;
     FindMapping(member: MemberInfo): CoreTypeMapping | undefined;
     FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | undefined;
+    ParseStoreTypeName(storeTypeName: string, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): string | undefined;
 }
 
 
-export const RelationalTypeMappingSource: {
-    new(dependencies: TypeMappingSourceDependencies, relationalDependencies: RelationalTypeMappingSourceDependencies): RelationalTypeMappingSource;
+export const RelationalTypeMappingSource: (abstract new(dependencies: TypeMappingSourceDependencies, relationalDependencies: RelationalTypeMappingSourceDependencies) => RelationalTypeMappingSource) & {
 };
 
 
@@ -1743,6 +1724,8 @@ export type RelationalTypeMappingSource = RelationalTypeMappingSource$instance &
 
 
 export interface RelationalTypeMappingSourceDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     Plugins: IEnumerable<IRelationalTypeMappingSourcePlugin>;
     _Clone_$(): RelationalTypeMappingSourceDependencies;
     Equals(obj: unknown): boolean;
@@ -1760,6 +1743,8 @@ export const RelationalTypeMappingSourceDependencies: {
 export type RelationalTypeMappingSourceDependencies = RelationalTypeMappingSourceDependencies$instance;
 
 export interface RetryLimitExceededException$instance extends Exception {
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -1773,133 +1758,105 @@ export const RetryLimitExceededException: {
 
 export type RetryLimitExceededException = RetryLimitExceededException$instance;
 
-export abstract class SByteTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface SByteTypeMapping$instance extends SByteTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface SByteTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const SByteTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): SByteTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): SByteTypeMapping;
     readonly Default: SByteTypeMapping;
 };
 
 
 export type SByteTypeMapping = SByteTypeMapping$instance;
 
-export abstract class ShortTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface ShortTypeMapping$instance extends ShortTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface ShortTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const ShortTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): ShortTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): ShortTypeMapping;
     readonly Default: ShortTypeMapping;
 };
 
 
 export type ShortTypeMapping = ShortTypeMapping$instance;
 
-export abstract class StringTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-    protected EscapeSqlLiteral(literal: string): string;
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-}
-
-
-export interface StringTypeMapping$instance extends StringTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface StringTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+    EscapeSqlLiteral(literal: string): string;
+    GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
 export const StringTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>, unicode: boolean, size: Nullable<System_Internal.Int32>): StringTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): StringTypeMapping;
     readonly Default: StringTypeMapping;
 };
 
 
 export type StringTypeMapping = StringTypeMapping$instance;
 
-export abstract class TimeOnlyTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-    protected GenerateNonNullSqlLiteral(value: unknown): string;
-}
-
-
-export interface TimeOnlyTypeMapping$instance extends TimeOnlyTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface TimeOnlyTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+    GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
 export const TimeOnlyTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): TimeOnlyTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): TimeOnlyTypeMapping;
     readonly Default: TimeOnlyTypeMapping;
 };
 
 
 export type TimeOnlyTypeMapping = TimeOnlyTypeMapping$instance;
 
-export abstract class TimeSpanTypeMapping$protected {
-    protected readonly SqlLiteralFormatString: string;
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface TimeSpanTypeMapping$instance extends TimeSpanTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface TimeSpanTypeMapping$instance extends RelationalTypeMapping {
+    readonly SqlLiteralFormatString: string;
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const TimeSpanTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): TimeSpanTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): TimeSpanTypeMapping;
     readonly Default: TimeSpanTypeMapping;
 };
 
 
 export type TimeSpanTypeMapping = TimeSpanTypeMapping$instance;
 
-export abstract class TypeMappingSource$protected {
-    protected FindCollectionMapping(info: TypeMappingInfo, modelType: Type, providerType: Type, elementMapping: CoreTypeMapping): CoreTypeMapping | undefined;
-    protected FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping | undefined;
-}
-
+export interface TypeMappingSource$instance extends TypeMappingSourceBase$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSource: never;
 
-export interface TypeMappingSource$instance extends TypeMappingSource$protected, TypeMappingSourceBase$instance {
+    FindCollectionMapping(info: TypeMappingInfo, modelType: Type, providerType: Type, elementMapping: CoreTypeMapping): CoreTypeMapping | undefined;
     FindMapping(property: IProperty): CoreTypeMapping | undefined;
     FindMapping(elementType: IElementType): CoreTypeMapping | undefined;
     FindMapping(type: Type): CoreTypeMapping | undefined;
     FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping): CoreTypeMapping | undefined;
     FindMapping(member: MemberInfo): CoreTypeMapping | undefined;
     FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | undefined;
+    FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping | undefined;
 }
 
 
-export const TypeMappingSource: {
-    new(dependencies: TypeMappingSourceDependencies): TypeMappingSource;
+export const TypeMappingSource: (abstract new(dependencies: TypeMappingSourceDependencies) => TypeMappingSource) & {
 };
 
 
@@ -1910,26 +1867,23 @@ export interface __TypeMappingSource$views {
 export type TypeMappingSource = TypeMappingSource$instance & __TypeMappingSource$views;
 
 
-export abstract class TypeMappingSourceBase$protected {
-    protected readonly Dependencies: TypeMappingSourceDependencies;
-    protected FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping | undefined;
-    protected TryFindJsonCollectionMapping(mappingInfo: TypeMappingInfo, modelClrType: Type, providerClrType: Type, elementMapping: CoreTypeMapping, elementComparer: ValueComparer, collectionReaderWriter: JsonValueReaderWriter): boolean;
-    protected ValidateMapping(mapping: CoreTypeMapping, property: IProperty): void;
-}
-
+export interface TypeMappingSourceBase$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSource: never;
 
-export interface TypeMappingSourceBase$instance extends TypeMappingSourceBase$protected {
+    readonly Dependencies: TypeMappingSourceDependencies;
+    FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping | undefined;
     FindMapping(property: IProperty): CoreTypeMapping | undefined;
     FindMapping(elementType: IElementType): CoreTypeMapping | undefined;
     FindMapping(type: Type): CoreTypeMapping | undefined;
     FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping): CoreTypeMapping | undefined;
     FindMapping(member: MemberInfo): CoreTypeMapping | undefined;
     FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | undefined;
+    TryFindJsonCollectionMapping(mappingInfo: TypeMappingInfo, modelClrType: Type, providerClrType: Type, elementMapping: CoreTypeMapping, elementComparer: ValueComparer, collectionReaderWriter: JsonValueReaderWriter): boolean;
+    ValidateMapping(mapping: CoreTypeMapping, property: IProperty): void;
 }
 
 
-export const TypeMappingSourceBase: {
-    new(dependencies: TypeMappingSourceDependencies): TypeMappingSourceBase;
+export const TypeMappingSourceBase: (abstract new(dependencies: TypeMappingSourceDependencies) => TypeMappingSourceBase) & {
 };
 
 
@@ -1941,6 +1895,8 @@ export type TypeMappingSourceBase = TypeMappingSourceBase$instance & __TypeMappi
 
 
 export interface TypeMappingSourceDependencies$instance {
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly JsonValueReaderWriterSource: IJsonValueReaderWriterSource;
     Plugins: IEnumerable<ITypeMappingSourcePlugin>;
     ValueConverterSelector: IValueConverterSelector;
@@ -1959,17 +1915,13 @@ export const TypeMappingSourceDependencies: {
 
 export type TypeMappingSourceDependencies = TypeMappingSourceDependencies$instance;
 
-export abstract class TypeMaterializationInfo$protected {
-    protected Equals(other: TypeMaterializationInfo): boolean;
-}
-
-
-export interface TypeMaterializationInfo$instance extends TypeMaterializationInfo$protected {
+export interface TypeMaterializationInfo$instance {
     readonly IsNullable: Nullable<System_Internal.Boolean>;
     readonly Mapping: RelationalTypeMapping;
     readonly ModelClrType: Type;
-    readonly Property: IProperty;
+    readonly Property: IProperty | undefined;
     readonly ProviderClrType: Type;
+    Equals(other: TypeMaterializationInfo): boolean;
     Equals(obj: unknown): boolean;
     GetHashCode(): int;
 }
@@ -1982,63 +1934,48 @@ export const TypeMaterializationInfo: {
 
 export type TypeMaterializationInfo = TypeMaterializationInfo$instance;
 
-export abstract class UIntTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface UIntTypeMapping$instance extends UIntTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface UIntTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const UIntTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): UIntTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): UIntTypeMapping;
     readonly Default: UIntTypeMapping;
 };
 
 
 export type UIntTypeMapping = UIntTypeMapping$instance;
 
-export abstract class ULongTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface ULongTypeMapping$instance extends ULongTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface ULongTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const ULongTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): ULongTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): ULongTypeMapping;
     readonly Default: ULongTypeMapping;
 };
 
 
 export type ULongTypeMapping = ULongTypeMapping$instance;
 
-export abstract class UShortTypeMapping$protected {
-    protected Clone5(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
-    protected Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
-}
-
-
-export interface UShortTypeMapping$instance extends UShortTypeMapping$protected, RelationalTypeMapping {
-    Clone2(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
-    Clone2(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
+export interface UShortTypeMapping$instance extends RelationalTypeMapping {
+    Clone(parameters: unknown): RelationalTypeMapping;
+    Clone(parameters: unknown): CoreTypeMapping;
+    Clone(mappingInfo?: Nullable<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable<TypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter): CoreTypeMapping;
 }
 
 
 export const UShortTypeMapping: {
     new(storeType: string, dbType: Nullable<DbType>): UShortTypeMapping;
-    new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): UShortTypeMapping;
     readonly Default: UShortTypeMapping;
 };