@tsonic/efcore 10.0.3 → 10.0.8

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

@@ -22,20 +22,20 @@ import type { IValueConverterSelector, ValueConverter, ValueConverter_2, ValueCo
 import type { IBatchExecutor, ICommandBatchPreparer, IUpdateAdapterFactory, IUpdateEntry } from "../../Microsoft.EntityFrameworkCore.Update/internal/index.js";
 import type { ValueGenerator } from "../../Microsoft.EntityFrameworkCore.ValueGeneration/internal/index.js";
 import type { DbContext, DbLoggerCategory_Database_Command, DbLoggerCategory_Database_Transaction, DbLoggerCategory_Infrastructure, DbLoggerCategory_Update } from "../../Microsoft.EntityFrameworkCore/internal/index.js";
-import type { IEnumerable, IList, IReadOnlyDictionary, IReadOnlyList, List } from "@tsonic/dotnet/System.Collections.Generic.js";
-import * as System_Data_Common_Internal from "@tsonic/dotnet/System.Data.Common.js";
-import type { DbCommand, DbConnection, DbDataReader, DbParameter, DbTransaction } from "@tsonic/dotnet/System.Data.Common.js";
-import type { DbType, IsolationLevel, ParameterDirection } from "@tsonic/dotnet/System.Data.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Action, Boolean as ClrBoolean, Enum, Exception, FormattableString, Func, Guid, IAsyncDisposable, IComparable, IConvertible, IDisposable, IEquatable, IFormattable, Int32, ISpanFormattable, Nullable, Object as ClrObject, Random, String as ClrString, TimeSpan, Type, ValueType, Void } from "@tsonic/dotnet/System.js";
-import type { Expression, LambdaExpression } from "@tsonic/dotnet/System.Linq.Expressions.js";
-import type { ConstructorInfo, MemberInfo, MethodInfo } from "@tsonic/dotnet/System.Reflection.js";
-import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization.js";
-import type { ISerializable, SerializationInfo, StreamingContext } from "@tsonic/dotnet/System.Runtime.Serialization.js";
-import type { StringBuilder } from "@tsonic/dotnet/System.Text.js";
-import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
-import type { Task, ValueTask } from "@tsonic/dotnet/System.Threading.Tasks.js";
-import type { Transaction } from "@tsonic/dotnet/System.Transactions.js";
+import type { IEnumerable_1, IList_1, IReadOnlyDictionary_2, IReadOnlyList_1, List_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import * as System_Data_Common_Internal from "@tsonic/dotnet/System.Data.Common/internal/index.js";
+import type { DbCommand, DbConnection, DbDataReader, DbParameter, DbTransaction } from "@tsonic/dotnet/System.Data.Common/internal/index.js";
+import type { DbType, IsolationLevel, ParameterDirection } from "@tsonic/dotnet/System.Data/internal/index.js";
+import type { Expression, Expression_1, LambdaExpression } from "@tsonic/dotnet/System.Linq.Expressions/internal/index.js";
+import type { ConstructorInfo, MemberInfo, MethodInfo } from "@tsonic/dotnet/System.Reflection/internal/index.js";
+import * as System_Runtime_Serialization_Internal from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
+import type { ISerializable, SerializationInfo, StreamingContext } from "@tsonic/dotnet/System.Runtime.Serialization/internal/index.js";
+import type { StringBuilder } from "@tsonic/dotnet/System.Text/internal/index.js";
+import type { Task, Task_1, ValueTask, ValueTask_1 } from "@tsonic/dotnet/System.Threading.Tasks/internal/index.js";
+import type { CancellationToken } from "@tsonic/dotnet/System.Threading/internal/index.js";
+import type { Transaction } from "@tsonic/dotnet/System.Transactions/internal/index.js";
+import * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
+import type { Action, Action_1, Boolean as ClrBoolean, Enum, Exception, FormattableString, Func_1, Func_2, Func_3, Func_4, Guid, IAsyncDisposable, IComparable, IConvertible, IDisposable, IEquatable_1, IFormattable, Int32, ISpanFormattable, Nullable_1, Object as ClrObject, Random, String as ClrString, TimeSpan, Type, ValueType, Void } from "@tsonic/dotnet/System/internal/index.js";
 
 export enum StoreTypePostfix {
     None = 0,
@@ -46,29 +46,35 @@ export enum StoreTypePostfix {
 
 
 export interface IDatabase$instance {
-    CompileQuery<TResult>(query: Expression, async: boolean): Func<QueryContext, TResult>;
-    CompileQueryExpression<TResult>(query: Expression, async: boolean): Expression<Func<QueryContext, TResult>>;
-    SaveChanges(entries: IList<IUpdateEntry>): int;
-    SaveChangesAsync(entries: IList<IUpdateEntry>, cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabase: never;
+
+    CompileQuery<TResult>(query: Expression, async: boolean): Func_2<QueryContext, TResult>;
+    CompileQueryExpression<TResult>(query: Expression, async: boolean): Expression_1<Func_2<QueryContext, TResult>>;
+    SaveChanges(entries: IList_1<IUpdateEntry>): int;
+    SaveChangesAsync(entries: IList_1<IUpdateEntry>, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
 }
 
 
 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>;
+    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
 }
 
 
 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;
     readonly ExecutionStrategyFactory: IExecutionStrategyFactory;
-    readonly DatabaseProviders: IEnumerable<IDatabaseProvider>;
+    readonly DatabaseProviders: IEnumerable_1<IDatabaseProvider>;
     readonly CommandLogger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Command>;
     readonly ConcurrencyDetector: IConcurrencyDetector;
     readonly CoreOptions: ICoreSingletonOptions;
@@ -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,12 +119,16 @@ 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>;
+    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
     CommitTransaction(): void;
     CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
     ResetState(): void;
@@ -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,15 +150,19 @@ 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>;
+    Execute<TState, TResult>(state: TState, operation: Func_3<DbContext, TState, TResult>, verifySucceeded: Func_3<DbContext, TState, ExecutionResult_1<TResult>>): TResult;
+    ExecuteAsync<TState, TResult>(state: TState, operation: Func_4<DbContext, TState, CancellationToken, Task_1<TResult>>, verifySucceeded: Func_4<DbContext, TState, CancellationToken, Task_1<ExecutionResult_1<TResult>>>, cancellationToken?: CancellationToken): Task_1<TResult>;
 }
 
 
 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,8 +179,10 @@ export interface IParameterNameGeneratorFactory$instance {
 export type IParameterNameGeneratorFactory = IParameterNameGeneratorFactory$instance;
 
 export interface IRawSqlCommandBuilder$instance {
-    Build(sql: string, parameters: IEnumerable<unknown>, model: IModel): RawSqlCommand;
-    Build(sql: string, parameters: IEnumerable<unknown>): RawSqlCommand;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRawSqlCommandBuilder: never;
+
+    Build(sql: string, parameters: IEnumerable_1<unknown>, model: IModel): RawSqlCommand;
+    Build(sql: string, parameters: IEnumerable_1<unknown>): RawSqlCommand;
     Build(sql: string): IRelationalCommand;
 }
 
@@ -164,12 +190,14 @@ 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>;
+    readonly Parameters: IReadOnlyList_1<IRelationalParameter>;
     CreateDbCommand(parameterObject: RelationalCommandParameterObject, commandId: Guid, commandMethod: DbCommandMethod): DbCommand;
     ExecuteNonQuery(parameterObject: RelationalCommandParameterObject): int;
-    ExecuteNonQueryAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
+    ExecuteNonQueryAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
     ExecuteReader(parameterObject: RelationalCommandParameterObject): RelationalDataReader;
     ExecuteScalar(parameterObject: RelationalCommandParameterObject): unknown | undefined;
     PopulateFrom(commandTemplate: IRelationalCommandTemplate): void;
@@ -181,7 +209,9 @@ export interface IRelationalCommand$instance extends IRelationalCommandTemplate$
 export type IRelationalCommand = IRelationalCommand$instance;
 
 export interface IRelationalCommandBuilder$instance {
-    readonly Parameters: IReadOnlyList<IRelationalParameter>;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilder: never;
+
+    readonly Parameters: IReadOnlyList_1<IRelationalParameter>;
     readonly TypeMappingSource: IRelationalTypeMappingSource;
     readonly CommandTextLength: int;
     AddParameter(parameter: IRelationalParameter): IRelationalCommandBuilder;
@@ -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,9 +235,11 @@ 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>;
+    readonly Parameters: IReadOnlyList_1<IRelationalParameter>;
     CreateDbCommand(parameterObject: RelationalCommandParameterObject, commandId: Guid, commandMethod: DbCommandMethod): DbCommand;
 }
 
@@ -213,45 +247,51 @@ 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 | undefined);
     DbConnection: DbConnection;
     readonly Context: DbContext;
     readonly ConnectionId: Guid;
-    CommandTimeout: Nullable<System_Internal.Int32>;
+    CommandTimeout: Nullable_1<System_Internal.Int32>;
     readonly CurrentTransaction: IDbContextTransaction | undefined;
     BeginTransaction(): IDbContextTransaction;
     BeginTransaction(isolationLevel: IsolationLevel): IDbContextTransaction;
-    BeginTransactionAsync(cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
-    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
+    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
+    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
     Close(): boolean;
-    CloseAsync(): Task<System_Internal.Boolean>;
+    CloseAsync(): Task_1<System_Internal.Boolean>;
     CommitTransaction(): void;
     CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
     Open(errorsExpected?: boolean): boolean;
-    OpenAsync(cancellationToken: CancellationToken, errorsExpected?: boolean): Task<System_Internal.Boolean>;
+    OpenAsync(cancellationToken: CancellationToken, errorsExpected?: boolean): Task_1<System_Internal.Boolean>;
     RentCommand(): IRelationalCommand;
     ReturnCommand(command: IRelationalCommand): void;
     SetDbConnection(value: DbConnection, contextOwnsConnection: boolean): void;
     UseTransaction(transaction: DbTransaction, transactionId: Guid): IDbContextTransaction | undefined;
     UseTransaction(transaction: DbTransaction): IDbContextTransaction | undefined;
-    UseTransactionAsync(transaction: DbTransaction, transactionId: Guid, cancellationToken?: CancellationToken): Task<IDbContextTransaction | undefined>;
-    UseTransactionAsync(transaction: DbTransaction, cancellationToken?: CancellationToken): Task<IDbContextTransaction | undefined>;
+    UseTransactionAsync(transaction: DbTransaction, transactionId: Guid, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | undefined>;
+    UseTransactionAsync(transaction: DbTransaction, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | undefined>;
     ResetState(): void;
     ResetStateAsync(cancellationToken?: CancellationToken): Task;
 }
 
 
+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;
-    ExistsAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    ExistsAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     GenerateCreateScript(): string;
     EnsureDeleted(): boolean;
-    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.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;
@@ -267,7 +309,7 @@ export interface IRelationalDatabaseFacadeDependencies$instance extends IDatabas
     readonly DatabaseCreator: IDatabaseCreator;
     readonly ExecutionStrategy: IExecutionStrategy;
     readonly ExecutionStrategyFactory: IExecutionStrategyFactory;
-    readonly DatabaseProviders: IEnumerable<IDatabaseProvider>;
+    readonly DatabaseProviders: IEnumerable_1<IDatabaseProvider>;
     readonly ConcurrencyDetector: IConcurrencyDetector;
     readonly CoreOptions: ICoreSingletonOptions;
     readonly QueryProvider: IAsyncQueryProvider;
@@ -279,8 +321,10 @@ 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, parameterValues: IReadOnlyDictionary_2<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,17 +341,19 @@ 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;
-    BeginTransactionAsync(cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
-    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
+    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
+    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
     CommitTransaction(): void;
     CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
     UseTransaction(transaction: DbTransaction, transactionId: Guid): IDbContextTransaction | undefined;
     UseTransaction(transaction: DbTransaction): IDbContextTransaction | undefined;
-    UseTransactionAsync(transaction: DbTransaction, transactionId: Guid, cancellationToken?: CancellationToken): Task<IDbContextTransaction | undefined>;
-    UseTransactionAsync(transaction: DbTransaction, cancellationToken?: CancellationToken): Task<IDbContextTransaction | undefined>;
+    UseTransactionAsync(transaction: DbTransaction, transactionId: Guid, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | undefined>;
+    UseTransactionAsync(transaction: DbTransaction, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | undefined>;
     ResetState(): void;
     ResetStateAsync(cancellationToken?: CancellationToken): Task;
 }
@@ -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;
@@ -324,7 +374,7 @@ export interface IRelationalTypeMappingSource$instance extends ITypeMappingSourc
     FindMapping(member: MemberInfo): RelationalTypeMapping | undefined;
     FindMapping(storeTypeName: string): RelationalTypeMapping | undefined;
     FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping): RelationalTypeMapping | undefined;
-    FindMapping(type: Type, storeTypeName: string, keyOrIndex?: boolean, unicode?: Nullable<System_Internal.Boolean>, size?: Nullable<System_Internal.Int32>, rowVersion?: Nullable<System_Internal.Boolean>, fixedLength?: Nullable<System_Internal.Boolean>, precision?: Nullable<System_Internal.Int32>, scale?: Nullable<System_Internal.Int32>): RelationalTypeMapping | undefined;
+    FindMapping(type: Type, storeTypeName: string, keyOrIndex?: boolean, unicode?: Nullable_1<System_Internal.Boolean>, size?: Nullable_1<System_Internal.Int32>, rowVersion?: Nullable_1<System_Internal.Boolean>, fixedLength?: Nullable_1<System_Internal.Boolean>, precision?: Nullable_1<System_Internal.Int32>, scale?: Nullable_1<System_Internal.Int32>): RelationalTypeMapping | undefined;
     FindMapping(type: Type): RelationalTypeMapping | 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;
 }
 
@@ -382,6 +442,8 @@ export interface ITypeMappingSourcePlugin$instance {
 export type ITypeMappingSourcePlugin = ITypeMappingSourcePlugin$instance;
 
 export interface MaterializationContext$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_MaterializationContext: never;
+
     readonly Context: DbContext;
     readonly ValueBuffer: ValueBuffer;
 }
@@ -396,13 +458,17 @@ export const MaterializationContext: {
 export type MaterializationContext = MaterializationContext$instance;
 
 export interface RelationalCommandParameterObject$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalCommandParameterObject: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly CommandSource: CommandSource;
     readonly Connection: IRelationalConnection;
     readonly Context: DbContext | undefined;
     readonly DetailedErrorsEnabled: boolean;
     readonly Logger: IRelationalCommandDiagnosticsLogger | undefined;
-    readonly ParameterValues: IReadOnlyDictionary<System_Internal.String, unknown | undefined> | undefined;
-    readonly ReaderColumns: IReadOnlyList<ReaderColumn | undefined> | undefined;
+    readonly ParameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | undefined> | undefined;
+    readonly ReaderColumns: IReadOnlyList_1<ReaderColumn | undefined> | undefined;
     Equals(obj: unknown): boolean;
     Equals(other: RelationalCommandParameterObject): boolean;
     GetHashCode(): int;
@@ -411,32 +477,36 @@ export interface RelationalCommandParameterObject$instance {
 
 
 export const RelationalCommandParameterObject: {
-    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary<System_Internal.String, unknown>, readerColumns: IReadOnlyList<ReaderColumn>, context: DbContext, logger: IRelationalCommandDiagnosticsLogger): RelationalCommandParameterObject;
-    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary<System_Internal.String, unknown>, readerColumns: IReadOnlyList<ReaderColumn>, context: DbContext, logger: IRelationalCommandDiagnosticsLogger, commandSource: CommandSource): RelationalCommandParameterObject;
-    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary<System_Internal.String, unknown>, readerColumns: IReadOnlyList<ReaderColumn>, context: DbContext, logger: IRelationalCommandDiagnosticsLogger, detailedErrorsEnabled: boolean): RelationalCommandParameterObject;
-    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary<System_Internal.String, unknown>, readerColumns: IReadOnlyList<ReaderColumn>, context: DbContext, logger: IRelationalCommandDiagnosticsLogger, detailedErrorsEnabled: boolean, commandSource: CommandSource): RelationalCommandParameterObject;
+    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown>, readerColumns: IReadOnlyList_1<ReaderColumn>, context: DbContext, logger: IRelationalCommandDiagnosticsLogger): RelationalCommandParameterObject;
+    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown>, readerColumns: IReadOnlyList_1<ReaderColumn>, context: DbContext, logger: IRelationalCommandDiagnosticsLogger, commandSource: CommandSource): RelationalCommandParameterObject;
+    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown>, readerColumns: IReadOnlyList_1<ReaderColumn>, context: DbContext, logger: IRelationalCommandDiagnosticsLogger, detailedErrorsEnabled: boolean): RelationalCommandParameterObject;
+    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown>, readerColumns: IReadOnlyList_1<ReaderColumn>, context: DbContext, logger: IRelationalCommandDiagnosticsLogger, detailedErrorsEnabled: boolean, commandSource: CommandSource): RelationalCommandParameterObject;
 };
 
 
 export type RelationalCommandParameterObject = RelationalCommandParameterObject$instance;
 
 export interface RelationalTypeMappingInfo$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTypeMappingInfo: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     get ClrType(): Type | undefined;
     set ClrType(value: Type | undefined);
     readonly CoreTypeMappingInfo: TypeMappingInfo;
-    DbType: Nullable<DbType>;
+    DbType: Nullable_1<DbType>;
     get ElementTypeMapping(): RelationalTypeMapping | undefined;
     set ElementTypeMapping(value: RelationalTypeMapping | undefined);
-    IsFixedLength: Nullable<System_Internal.Boolean>;
+    IsFixedLength: Nullable_1<System_Internal.Boolean>;
     IsKey: boolean;
     IsKeyOrIndex: boolean;
-    IsRowVersion: Nullable<System_Internal.Boolean>;
-    IsUnicode: Nullable<System_Internal.Boolean>;
+    IsRowVersion: Nullable_1<System_Internal.Boolean>;
+    IsUnicode: Nullable_1<System_Internal.Boolean>;
     get JsonValueReaderWriter(): JsonValueReaderWriter | undefined;
     set JsonValueReaderWriter(value: JsonValueReaderWriter | undefined);
-    Precision: Nullable<System_Internal.Int32>;
-    Scale: Nullable<System_Internal.Int32>;
-    Size: Nullable<System_Internal.Int32>;
+    Precision: Nullable_1<System_Internal.Int32>;
+    Scale: Nullable_1<System_Internal.Int32>;
+    Size: Nullable_1<System_Internal.Int32>;
     get StoreTypeName(): string | undefined;
     set StoreTypeName(value: string | undefined);
     get StoreTypeNameBase(): string | undefined;
@@ -451,32 +521,36 @@ export interface RelationalTypeMappingInfo$instance {
 
 export const RelationalTypeMappingInfo: {
     new(property: IProperty): RelationalTypeMappingInfo;
-    new(elementType: IElementType, storeTypeName: string, storeTypeNameBase: string, fallbackUnicode: Nullable<System_Internal.Boolean>, fallbackFixedLength: Nullable<System_Internal.Boolean>, fallbackSize: Nullable<System_Internal.Int32>, fallbackPrecision: Nullable<System_Internal.Int32>, fallbackScale: Nullable<System_Internal.Int32>): RelationalTypeMappingInfo;
-    new(principals: IReadOnlyList<IProperty>, storeTypeName: string, storeTypeNameBase: string, fallbackUnicode: Nullable<System_Internal.Boolean>, fallbackFixedLength: Nullable<System_Internal.Boolean>, fallbackSize: Nullable<System_Internal.Int32>, fallbackPrecision: Nullable<System_Internal.Int32>, fallbackScale: Nullable<System_Internal.Int32>): RelationalTypeMappingInfo;
-    new(storeTypeName: string, storeTypeNameBase: string, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): RelationalTypeMappingInfo;
-    new(member: MemberInfo, elementTypeMapping: RelationalTypeMapping, storeTypeName: string, storeTypeNameBase: string, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): RelationalTypeMappingInfo;
+    new(elementType: IElementType, storeTypeName: string, storeTypeNameBase: string, fallbackUnicode: Nullable_1<System_Internal.Boolean>, fallbackFixedLength: Nullable_1<System_Internal.Boolean>, fallbackSize: Nullable_1<System_Internal.Int32>, fallbackPrecision: Nullable_1<System_Internal.Int32>, fallbackScale: Nullable_1<System_Internal.Int32>): RelationalTypeMappingInfo;
+    new(principals: IReadOnlyList_1<IProperty>, storeTypeName: string, storeTypeNameBase: string, fallbackUnicode: Nullable_1<System_Internal.Boolean>, fallbackFixedLength: Nullable_1<System_Internal.Boolean>, fallbackSize: Nullable_1<System_Internal.Int32>, fallbackPrecision: Nullable_1<System_Internal.Int32>, fallbackScale: Nullable_1<System_Internal.Int32>): RelationalTypeMappingInfo;
+    new(storeTypeName: string, storeTypeNameBase: string, unicode: Nullable_1<System_Internal.Boolean>, size: Nullable_1<System_Internal.Int32>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): RelationalTypeMappingInfo;
+    new(member: MemberInfo, elementTypeMapping: RelationalTypeMapping, storeTypeName: string, storeTypeNameBase: string, unicode: Nullable_1<System_Internal.Boolean>, size: Nullable_1<System_Internal.Int32>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): RelationalTypeMappingInfo;
     new(source: RelationalTypeMappingInfo, converter: ValueConverterInfo): RelationalTypeMappingInfo;
-    new(type: Type, elementTypeMapping: RelationalTypeMapping, storeTypeName: string, storeTypeNameBase: string, keyOrIndex: boolean, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, rowVersion: Nullable<System_Internal.Boolean>, fixedLength: Nullable<System_Internal.Boolean>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>, dbType: Nullable<DbType>, key: boolean): RelationalTypeMappingInfo;
-    new(type: Type, typeMappingConfiguration: ITypeMappingConfiguration, elementTypeMapping: RelationalTypeMapping, storeTypeName: string, storeTypeNameBase: string, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): RelationalTypeMappingInfo;
+    new(type: Type, elementTypeMapping: RelationalTypeMapping, storeTypeName: string, storeTypeNameBase: string, keyOrIndex: boolean, unicode: Nullable_1<System_Internal.Boolean>, size: Nullable_1<System_Internal.Int32>, rowVersion: Nullable_1<System_Internal.Boolean>, fixedLength: Nullable_1<System_Internal.Boolean>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>, dbType: Nullable_1<DbType>, key: boolean): RelationalTypeMappingInfo;
+    new(type: Type, typeMappingConfiguration: ITypeMappingConfiguration, elementTypeMapping: RelationalTypeMapping, storeTypeName: string, storeTypeNameBase: string, unicode: Nullable_1<System_Internal.Boolean>, size: Nullable_1<System_Internal.Int32>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): RelationalTypeMappingInfo;
 };
 
 
 export type RelationalTypeMappingInfo = RelationalTypeMappingInfo$instance;
 
 export interface TypeMappingInfo$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TypeMappingInfo: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     get ClrType(): Type | undefined;
     set ClrType(value: Type | undefined);
     get ElementTypeMapping(): CoreTypeMapping | undefined;
     set ElementTypeMapping(value: CoreTypeMapping | undefined);
     IsKey: boolean;
     IsKeyOrIndex: boolean;
-    IsRowVersion: Nullable<System_Internal.Boolean>;
-    IsUnicode: Nullable<System_Internal.Boolean>;
+    IsRowVersion: Nullable_1<System_Internal.Boolean>;
+    IsUnicode: Nullable_1<System_Internal.Boolean>;
     get JsonValueReaderWriter(): JsonValueReaderWriter | undefined;
     set JsonValueReaderWriter(value: JsonValueReaderWriter | undefined);
-    Precision: Nullable<System_Internal.Int32>;
-    Scale: Nullable<System_Internal.Int32>;
-    Size: Nullable<System_Internal.Int32>;
+    Precision: Nullable_1<System_Internal.Int32>;
+    Scale: Nullable_1<System_Internal.Int32>;
+    Size: Nullable_1<System_Internal.Int32>;
     Equals(obj: unknown): boolean;
     Equals(other: TypeMappingInfo): boolean;
     GetHashCode(): int;
@@ -487,18 +561,22 @@ export interface TypeMappingInfo$instance {
 
 export const TypeMappingInfo: {
     new(property: IProperty): TypeMappingInfo;
-    new(elementType: IElementType, fallbackUnicode: Nullable<System_Internal.Boolean>, fallbackSize: Nullable<System_Internal.Int32>, fallbackPrecision: Nullable<System_Internal.Int32>, fallbackScale: Nullable<System_Internal.Int32>): TypeMappingInfo;
-    new(principals: IReadOnlyList<IProperty>, fallbackUnicode: Nullable<System_Internal.Boolean>, fallbackSize: Nullable<System_Internal.Int32>, fallbackPrecision: Nullable<System_Internal.Int32>, fallbackScale: Nullable<System_Internal.Int32>): TypeMappingInfo;
-    new(member: MemberInfo, elementTypeMapping: CoreTypeMapping, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): TypeMappingInfo;
+    new(elementType: IElementType, fallbackUnicode: Nullable_1<System_Internal.Boolean>, fallbackSize: Nullable_1<System_Internal.Int32>, fallbackPrecision: Nullable_1<System_Internal.Int32>, fallbackScale: Nullable_1<System_Internal.Int32>): TypeMappingInfo;
+    new(principals: IReadOnlyList_1<IProperty>, fallbackUnicode: Nullable_1<System_Internal.Boolean>, fallbackSize: Nullable_1<System_Internal.Int32>, fallbackPrecision: Nullable_1<System_Internal.Int32>, fallbackScale: Nullable_1<System_Internal.Int32>): TypeMappingInfo;
+    new(member: MemberInfo, elementTypeMapping: CoreTypeMapping, unicode: Nullable_1<System_Internal.Boolean>, size: Nullable_1<System_Internal.Int32>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): TypeMappingInfo;
     new(type: Type, typeMappingConfiguration: ITypeMappingConfiguration, elementTypeMapping: CoreTypeMapping): TypeMappingInfo;
-    new(type: Type, elementTypeMapping: CoreTypeMapping, keyOrIndex: boolean, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, rowVersion: Nullable<System_Internal.Boolean>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>, key: boolean): TypeMappingInfo;
-    new(source: TypeMappingInfo, converter: ValueConverterInfo, unicode: Nullable<System_Internal.Boolean>, size: Nullable<System_Internal.Int32>, precision: Nullable<System_Internal.Int32>, scale: Nullable<System_Internal.Int32>): TypeMappingInfo;
+    new(type: Type, elementTypeMapping: CoreTypeMapping, keyOrIndex: boolean, unicode: Nullable_1<System_Internal.Boolean>, size: Nullable_1<System_Internal.Int32>, rowVersion: Nullable_1<System_Internal.Boolean>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>, key: boolean): TypeMappingInfo;
+    new(source: TypeMappingInfo, converter: ValueConverterInfo, unicode: Nullable_1<System_Internal.Boolean>, size: Nullable_1<System_Internal.Int32>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): TypeMappingInfo;
 };
 
 
 export type TypeMappingInfo = TypeMappingInfo$instance;
 
 export interface ValueBuffer$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ValueBuffer: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly Count: int;
     readonly IsEmpty: boolean;
     [index: number]: unknown | undefined;
@@ -517,16 +595,18 @@ export const ValueBuffer: {
 export type ValueBuffer = ValueBuffer$instance;
 
 export interface BoolTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_BoolTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): BoolTypeMapping;
     readonly Default: BoolTypeMapping;
 };
 
@@ -534,16 +614,18 @@ export const BoolTypeMapping: {
 export type BoolTypeMapping = BoolTypeMapping$instance;
 
 export interface ByteArrayTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ByteArrayTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>, size: Nullable_1<System_Internal.Int32>): ByteArrayTypeMapping;
     readonly Default: ByteArrayTypeMapping;
 };
 
@@ -551,15 +633,17 @@ export const ByteArrayTypeMapping: {
 export type ByteArrayTypeMapping = ByteArrayTypeMapping$instance;
 
 export interface ByteTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ByteTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): ByteTypeMapping;
     readonly Default: ByteTypeMapping;
 };
 
@@ -567,16 +651,18 @@ export const ByteTypeMapping: {
 export type ByteTypeMapping = ByteTypeMapping$instance;
 
 export interface CharTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_CharTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): CharTypeMapping;
     readonly Default: CharTypeMapping;
 };
 
@@ -584,6 +670,8 @@ export const CharTypeMapping: {
 export type CharTypeMapping = CharTypeMapping$instance;
 
 export interface CoreTypeMapping$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_CoreTypeMapping: never;
+
     readonly ClrType: Type;
     readonly Comparer: ValueComparer;
     readonly Converter: ValueConverter | undefined;
@@ -592,9 +680,9 @@ export interface CoreTypeMapping$instance {
     readonly KeyComparer: ValueComparer;
     readonly Parameters: unknown;
     readonly ProviderValueComparer: ValueComparer;
-    readonly ValueGeneratorFactory: Func<IProperty, IEntityType, ValueGenerator> | undefined;
+    readonly ValueGeneratorFactory: Func_3<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;
+    Clone(mappingInfo?: Nullable_1<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;
 }
@@ -606,12 +694,16 @@ export const CoreTypeMapping: (abstract new(parameters: unknown) => CoreTypeMapp
 
 export type CoreTypeMapping = CoreTypeMapping$instance;
 
-export interface Database$instance {
+export interface Database$instance extends IDatabase$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_Database: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabase: never;
+
     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;
-    SaveChangesAsync(entries: IList<IUpdateEntry>, cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
+    CompileQuery<TResult>(query: Expression, async: boolean): Func_2<QueryContext, TResult>;
+    CompileQueryExpression<TResult>(query: Expression, async: boolean): Expression_1<Func_2<QueryContext, TResult>>;
+    SaveChanges(entries: IList_1<IUpdateEntry>): int;
+    SaveChangesAsync(entries: IList_1<IUpdateEntry>, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
 }
 
 
@@ -623,12 +715,14 @@ export interface __Database$views {
     As_IDatabase(): IDatabase$instance;
 }
 
-export interface Database$instance extends IDatabase$instance {}
-
 export type Database = Database$instance & __Database$views;
 
 
 export interface DatabaseDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DatabaseDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly Logger: IDiagnosticsLogger_1<DbLoggerCategory_Update>;
     QueryCompilationContextFactory: IQueryCompilationContextFactory;
     UpdateAdapterFactory: IUpdateAdapterFactory;
@@ -647,7 +741,11 @@ export const DatabaseDependencies: {
 
 export type DatabaseDependencies = DatabaseDependencies$instance;
 
-export interface DatabaseProvider_1$instance<TOptionsExtension extends IDbContextOptionsExtension> {
+export interface DatabaseProvider_1$instance<TOptionsExtension extends IDbContextOptionsExtension> extends IDatabaseProvider$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DatabaseProvider_1: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseProvider: never;
+
     readonly Dependencies: DatabaseProviderDependencies;
     readonly Name: string;
     readonly Version: string | undefined;
@@ -664,12 +762,14 @@ export interface __DatabaseProvider_1$views<TOptionsExtension extends IDbContext
     As_IDatabaseProvider(): IDatabaseProvider$instance;
 }
 
-export interface DatabaseProvider_1$instance<TOptionsExtension extends IDbContextOptionsExtension> extends IDatabaseProvider$instance {}
-
 export type DatabaseProvider_1<TOptionsExtension extends IDbContextOptionsExtension> = DatabaseProvider_1$instance<TOptionsExtension> & __DatabaseProvider_1$views<TOptionsExtension>;
 
 
 export interface DatabaseProviderDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DatabaseProviderDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     _Clone_$(): DatabaseProviderDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: DatabaseProviderDependencies): boolean;
@@ -686,16 +786,18 @@ export const DatabaseProviderDependencies: {
 export type DatabaseProviderDependencies = DatabaseProviderDependencies$instance;
 
 export interface DateOnlyTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DateOnlyTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): DateOnlyTypeMapping;
     readonly Default: DateOnlyTypeMapping;
 };
 
@@ -703,16 +805,18 @@ export const DateOnlyTypeMapping: {
 export type DateOnlyTypeMapping = DateOnlyTypeMapping$instance;
 
 export interface DateTimeOffsetTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DateTimeOffsetTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): DateTimeOffsetTypeMapping;
     readonly Default: DateTimeOffsetTypeMapping;
 };
 
@@ -720,16 +824,18 @@ export const DateTimeOffsetTypeMapping: {
 export type DateTimeOffsetTypeMapping = DateTimeOffsetTypeMapping$instance;
 
 export interface DateTimeTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DateTimeTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): DateTimeTypeMapping;
     readonly Default: DateTimeTypeMapping;
 };
 
@@ -737,16 +843,18 @@ export const DateTimeTypeMapping: {
 export type DateTimeTypeMapping = DateTimeTypeMapping$instance;
 
 export interface DecimalTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DecimalTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): DecimalTypeMapping;
     readonly Default: DecimalTypeMapping;
 };
 
@@ -754,16 +862,18 @@ export const DecimalTypeMapping: {
 export type DecimalTypeMapping = DecimalTypeMapping$instance;
 
 export interface DoubleTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DoubleTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): DoubleTypeMapping;
     readonly Default: DoubleTypeMapping;
 };
 
@@ -771,6 +881,8 @@ export const DoubleTypeMapping: {
 export type DoubleTypeMapping = DoubleTypeMapping$instance;
 
 export interface ExecutionResult_1$instance<TResult> {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ExecutionResult_1: never;
+
     readonly IsSuccessful: boolean;
     readonly Result: TResult;
 }
@@ -783,16 +895,20 @@ export const ExecutionResult_1: {
 
 export type ExecutionResult_1<TResult> = ExecutionResult_1$instance<TResult>;
 
-export interface ExecutionStrategy$instance {
+export interface ExecutionStrategy$instance extends IExecutionStrategy$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ExecutionStrategy: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategy: never;
+
     readonly Dependencies: ExecutionStrategyDependencies;
-    readonly ExceptionsEncountered: List<Exception>;
+    readonly ExceptionsEncountered: List_1<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>;
+    Execute<TState, TResult>(state: TState, operation: Func_3<DbContext, TState, TResult>, verifySucceeded: Func_3<DbContext, TState, ExecutionResult_1<TResult>>): TResult;
+    ExecuteAsync<TState, TResult>(state: TState, operation: Func_4<DbContext, TState, CancellationToken, Task_1<TResult>>, verifySucceeded: Func_4<DbContext, TState, CancellationToken, Task_1<ExecutionResult_1<TResult>>>, cancellationToken?: CancellationToken): Task_1<TResult>;
+    GetNextDelay(lastException: Exception): Nullable_1<TimeSpan>;
     OnFirstExecution(): void;
     OnRetry(): void;
     ShouldRetryOn(exception: Exception): boolean;
@@ -805,7 +921,7 @@ export const ExecutionStrategy: (abstract new(context: DbContext, maxRetryCount:
     readonly DefaultMaxDelay: TimeSpan;
     get Current(): ExecutionStrategy | undefined;
     set Current(value: ExecutionStrategy | undefined);
-    CallOnWrappedException<TResult>(exception: Exception, exceptionHandler: Func<Exception, TResult>): TResult;
+    CallOnWrappedException<TResult>(exception: Exception, exceptionHandler: Func_2<Exception, TResult>): TResult;
 };
 
 
@@ -813,12 +929,14 @@ export interface __ExecutionStrategy$views {
     As_IExecutionStrategy(): IExecutionStrategy$instance;
 }
 
-export interface ExecutionStrategy$instance extends IExecutionStrategy$instance {}
-
 export type ExecutionStrategy = ExecutionStrategy$instance & __ExecutionStrategy$views;
 
 
 export interface ExecutionStrategyDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ExecutionStrategyDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     CurrentContext: ICurrentDbContext;
     Logger: IDiagnosticsLogger_1<DbLoggerCategory_Infrastructure>;
     Options: IDbContextOptions;
@@ -838,16 +956,18 @@ export const ExecutionStrategyDependencies: {
 export type ExecutionStrategyDependencies = ExecutionStrategyDependencies$instance;
 
 export interface FloatTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_FloatTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): FloatTypeMapping;
     readonly Default: FloatTypeMapping;
 };
 
@@ -855,16 +975,18 @@ export const FloatTypeMapping: {
 export type FloatTypeMapping = FloatTypeMapping$instance;
 
 export interface GuidTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_GuidTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): GuidTypeMapping;
     readonly Default: GuidTypeMapping;
 };
 
@@ -872,15 +994,17 @@ export const GuidTypeMapping: {
 export type GuidTypeMapping = GuidTypeMapping$instance;
 
 export interface IntTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_IntTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): IntTypeMapping;
     readonly Default: IntTypeMapping;
 };
 
@@ -888,17 +1012,21 @@ export const IntTypeMapping: {
 export type IntTypeMapping = IntTypeMapping$instance;
 
 export interface JsonTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_JsonTypeMapping: never;
+
     GenerateNonNullSqlLiteral(value: unknown): string;
 }
 
 
-export const JsonTypeMapping: (abstract new(storeType: string, clrType: Type, dbType: Nullable<DbType>) => JsonTypeMapping) & (abstract new(parameters: unknown) => JsonTypeMapping) & {
+export const JsonTypeMapping: (abstract new(storeType: string, clrType: Type, dbType: Nullable_1<DbType>) => JsonTypeMapping) & (abstract new(parameters: unknown) => JsonTypeMapping) & {
 };
 
 
 export type JsonTypeMapping = JsonTypeMapping$instance;
 
 export interface JsonTypePlaceholder$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_JsonTypePlaceholder: never;
+
 }
 
 
@@ -909,25 +1037,31 @@ export const JsonTypePlaceholder: {
 export type JsonTypePlaceholder = JsonTypePlaceholder$instance;
 
 export interface LongTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_LongTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): LongTypeMapping;
     readonly Default: LongTypeMapping;
 };
 
 
 export type LongTypeMapping = LongTypeMapping$instance;
 
-export interface NonRetryingExecutionStrategy$instance {
+export interface NonRetryingExecutionStrategy$instance extends IExecutionStrategy$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_NonRetryingExecutionStrategy: never;
+
+    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>;
+    Execute<TState, TResult>(state: TState, operation: Func_3<DbContext, TState, TResult>, verifySucceeded: Func_3<DbContext, TState, ExecutionResult_1<TResult>>): TResult;
+    ExecuteAsync<TState, TResult>(state: TState, operation: Func_4<DbContext, TState, CancellationToken, Task_1<TResult>>, verifySucceeded: Func_4<DbContext, TState, CancellationToken, Task_1<ExecutionResult_1<TResult>>>, cancellationToken?: CancellationToken): Task_1<TResult>;
 }
 
 
@@ -941,12 +1075,12 @@ export interface __NonRetryingExecutionStrategy$views {
     As_IExecutionStrategy(): IExecutionStrategy$instance;
 }
 
-export interface NonRetryingExecutionStrategy$instance extends IExecutionStrategy$instance {}
-
 export type NonRetryingExecutionStrategy = NonRetryingExecutionStrategy$instance & __NonRetryingExecutionStrategy$views;
 
 
 export interface ParameterNameGenerator$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ParameterNameGenerator: never;
+
     GenerateNext(): string;
     Reset(): void;
 }
@@ -960,6 +1094,10 @@ export const ParameterNameGenerator: {
 export type ParameterNameGenerator = ParameterNameGenerator$instance;
 
 export interface ParameterNameGeneratorDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ParameterNameGeneratorDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     _Clone_$(): ParameterNameGeneratorDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: ParameterNameGeneratorDependencies): boolean;
@@ -975,7 +1113,11 @@ export const ParameterNameGeneratorDependencies: {
 
 export type ParameterNameGeneratorDependencies = ParameterNameGeneratorDependencies$instance;
 
-export interface ParameterNameGeneratorFactory$instance {
+export interface ParameterNameGeneratorFactory$instance extends IParameterNameGeneratorFactory$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ParameterNameGeneratorFactory: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IParameterNameGeneratorFactory: never;
+
     readonly Dependencies: ParameterNameGeneratorDependencies;
     Create(): ParameterNameGenerator;
 }
@@ -990,25 +1132,27 @@ export interface __ParameterNameGeneratorFactory$views {
     As_IParameterNameGeneratorFactory(): IParameterNameGeneratorFactory$instance;
 }
 
-export interface ParameterNameGeneratorFactory$instance extends IParameterNameGeneratorFactory$instance {}
-
 export type ParameterNameGeneratorFactory = ParameterNameGeneratorFactory$instance & __ParameterNameGeneratorFactory$views;
 
 
 export interface RawSqlCommand$instance {
-    readonly ParameterValues: IReadOnlyDictionary<System_Internal.String, unknown | undefined>;
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RawSqlCommand: never;
+
+    readonly ParameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | undefined>;
     readonly RelationalCommand: IRelationalCommand;
 }
 
 
 export const RawSqlCommand: {
-    new(relationalCommand: IRelationalCommand, parameterValues: IReadOnlyDictionary<System_Internal.String, unknown>): RawSqlCommand;
+    new(relationalCommand: IRelationalCommand, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown>): RawSqlCommand;
 };
 
 
 export type RawSqlCommand = RawSqlCommand$instance;
 
 export interface ReaderColumn$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ReaderColumn: never;
+
     readonly GetFieldValueExpression: LambdaExpression;
     readonly IsNullable: boolean;
     readonly Name: string | undefined;
@@ -1026,36 +1170,43 @@ export const ReaderColumn: (abstract new(type: Type, nullable: boolean, name: st
 export type ReaderColumn = ReaderColumn$instance;
 
 export interface ReaderColumn_1$instance<T> extends ReaderColumn {
-    readonly GetFieldValue: Func<DbDataReader, int[], T>;
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ReaderColumn_1: never;
+
+    readonly GetFieldValue: Func_3<DbDataReader, int[], T>;
 }
 
 
 export const ReaderColumn_1: {
-    new<T>(nullable: boolean, name: string, property: IPropertyBase, getFieldValueExpression: Expression<Func<DbDataReader, int[], T>>): ReaderColumn_1<T>;
+    new<T>(nullable: boolean, name: string, property: IPropertyBase, getFieldValueExpression: Expression_1<Func_3<DbDataReader, int[], T>>): ReaderColumn_1<T>;
 };
 
 
 export type ReaderColumn_1<T> = ReaderColumn_1$instance<T>;
 
 export interface RelationalCommand$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalCommand: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommand: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandTemplate: never;
+
     CommandText: string;
     readonly Dependencies: RelationalCommandBuilderDependencies;
     LogCommandText: string;
-    Parameters: IReadOnlyList<IRelationalParameter>;
+    Parameters: IReadOnlyList_1<IRelationalParameter>;
     CreateDbCommand(parameterObject: RelationalCommandParameterObject, commandId: Guid, commandMethod: DbCommandMethod): DbCommand;
     CreateRelationalDataReader(): RelationalDataReader;
     ExecuteNonQuery(parameterObject: RelationalCommandParameterObject): int;
-    ExecuteNonQueryAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
+    ExecuteNonQueryAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
     ExecuteReader(parameterObject: RelationalCommandParameterObject): RelationalDataReader;
-    ExecuteReaderAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task<RelationalDataReader>;
+    ExecuteReaderAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task_1<RelationalDataReader>;
     ExecuteScalar(parameterObject: RelationalCommandParameterObject): unknown | undefined;
-    ExecuteScalarAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task<unknown | undefined>;
+    ExecuteScalarAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task_1<unknown | undefined>;
     PopulateFrom(commandTemplate: IRelationalCommandTemplate): void;
 }
 
 
 export const RelationalCommand: {
-    new(dependencies: RelationalCommandBuilderDependencies, commandText: string, logCommandText: string, parameters: IReadOnlyList<IRelationalParameter>): RelationalCommand;
+    new(dependencies: RelationalCommandBuilderDependencies, commandText: string, logCommandText: string, parameters: IReadOnlyList_1<IRelationalParameter>): RelationalCommand;
 };
 
 
@@ -1068,9 +1219,13 @@ export type RelationalCommand = RelationalCommand$instance & __RelationalCommand
 
 
 export interface RelationalCommandBuilder$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalCommandBuilder: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilder: never;
+
     readonly CommandTextLength: int;
     readonly Dependencies: RelationalCommandBuilderDependencies;
-    readonly Parameters: IReadOnlyList<IRelationalParameter>;
+    readonly Parameters: IReadOnlyList_1<IRelationalParameter>;
     readonly TypeMappingSource: IRelationalTypeMappingSource;
     AddParameter(parameter: IRelationalParameter): IRelationalCommandBuilder;
     Append(value: string, sensitive?: boolean): IRelationalCommandBuilder;
@@ -1097,6 +1252,10 @@ export type RelationalCommandBuilder = RelationalCommandBuilder$instance & __Rel
 
 
 export interface RelationalCommandBuilderDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalCommandBuilderDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     ExceptionDetector: IExceptionDetector;
     LoggingOptions: ILoggingOptions;
     TypeMappingSource: IRelationalTypeMappingSource;
@@ -1115,7 +1274,11 @@ export const RelationalCommandBuilderDependencies: {
 
 export type RelationalCommandBuilderDependencies = RelationalCommandBuilderDependencies$instance;
 
-export interface RelationalCommandBuilderFactory$instance {
+export interface RelationalCommandBuilderFactory$instance extends IRelationalCommandBuilderFactory$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalCommandBuilderFactory: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilderFactory: never;
+
     readonly Dependencies: RelationalCommandBuilderDependencies;
     Create(): IRelationalCommandBuilder;
 }
@@ -1130,13 +1293,21 @@ export interface __RelationalCommandBuilderFactory$views {
     As_IRelationalCommandBuilderFactory(): IRelationalCommandBuilderFactory$instance;
 }
 
-export interface RelationalCommandBuilderFactory$instance extends IRelationalCommandBuilderFactory$instance {}
-
 export type RelationalCommandBuilderFactory = RelationalCommandBuilderFactory$instance & __RelationalCommandBuilderFactory$views;
 
 
 export interface RelationalConnection$instance {
-    CommandTimeout: Nullable<System_Internal.Int32>;
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalConnection: never;
+
+    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;
+
+    CommandTimeout: Nullable_1<System_Internal.Int32>;
     readonly ConnectionId: Guid;
     get ConnectionString(): string | undefined;
     set ConnectionString(value: string | undefined);
@@ -1151,16 +1322,16 @@ export interface RelationalConnection$instance {
     readonly SupportsAmbientTransactions: boolean;
     BeginTransaction(): IDbContextTransaction;
     BeginTransaction(isolationLevel: IsolationLevel): IDbContextTransaction;
-    BeginTransactionAsync(cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
-    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
+    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
+    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
     Close(): boolean;
-    CloseAsync(): Task<System_Internal.Boolean>;
+    CloseAsync(): Task_1<System_Internal.Boolean>;
     CloseDbConnection(): void;
     CloseDbConnectionAsync(): Task;
     CommitTransaction(): void;
     CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
     ConnectionBeginTransaction(isolationLevel: IsolationLevel): DbTransaction;
-    ConnectionBeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): ValueTask<DbTransaction>;
+    ConnectionBeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): ValueTask_1<DbTransaction>;
     ConnectionEnlistTransaction(transaction: Transaction): void;
     CreateDbConnection(): DbConnection;
     Dispose(): void;
@@ -1170,7 +1341,7 @@ export interface RelationalConnection$instance {
     EnlistTransaction(transaction: Transaction): void;
     GetValidatedConnectionString(): string;
     Open(errorsExpected?: boolean): boolean;
-    OpenAsync(cancellationToken: CancellationToken, errorsExpected?: boolean): Task<System_Internal.Boolean>;
+    OpenAsync(cancellationToken: CancellationToken, errorsExpected?: boolean): Task_1<System_Internal.Boolean>;
     OpenDbConnection(errorsExpected: boolean): void;
     OpenDbConnectionAsync(errorsExpected: boolean, cancellationToken: CancellationToken): Task;
     RentCommand(): IRelationalCommand;
@@ -1182,8 +1353,8 @@ export interface RelationalConnection$instance {
     SetDbConnection(value: DbConnection, contextOwnsConnection: boolean): void;
     UseTransaction(transaction: DbTransaction): IDbContextTransaction | undefined;
     UseTransaction(transaction: DbTransaction, transactionId: Guid): IDbContextTransaction | undefined;
-    UseTransactionAsync(transaction: DbTransaction, cancellationToken?: CancellationToken): Task<IDbContextTransaction | undefined>;
-    UseTransactionAsync(transaction: DbTransaction, transactionId: Guid, cancellationToken?: CancellationToken): Task<IDbContextTransaction | undefined>;
+    UseTransactionAsync(transaction: DbTransaction, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | undefined>;
+    UseTransactionAsync(transaction: DbTransaction, transactionId: Guid, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | undefined>;
 }
 
 
@@ -1203,6 +1374,10 @@ export type RelationalConnection = RelationalConnection$instance & __RelationalC
 
 
 export interface RelationalConnectionDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalConnectionDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     ConnectionLogger: IRelationalConnectionDiagnosticsLogger;
     ConnectionStringResolver: INamedConnectionStringResolver;
     ContextOptions: IDbContextOptions;
@@ -1227,11 +1402,15 @@ export const RelationalConnectionDependencies: {
 export type RelationalConnectionDependencies = RelationalConnectionDependencies$instance;
 
 export interface RelationalDatabase$instance extends Database$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalDatabase: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabase: never;
+
     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;
-    SaveChangesAsync(entries: IList<IUpdateEntry>, cancellationToken?: CancellationToken): Task<System_Internal.Int32>;
+    CompileQuery<TResult>(query: Expression, async: boolean): Func_2<QueryContext, TResult>;
+    CompileQueryExpression<TResult>(query: Expression, async: boolean): Expression_1<Func_2<QueryContext, TResult>>;
+    SaveChanges(entries: IList_1<IUpdateEntry>): int;
+    SaveChangesAsync(entries: IList_1<IUpdateEntry>, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
 }
 
 
@@ -1247,10 +1426,15 @@ export interface __RelationalDatabase$views {
 export type RelationalDatabase = RelationalDatabase$instance & __RelationalDatabase$views;
 
 
-export interface RelationalDatabaseCreator$instance {
+export interface RelationalDatabaseCreator$instance extends IRelationalDatabaseCreator$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalDatabaseCreator: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseCreator: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalDatabaseCreator: never;
+
     readonly Dependencies: RelationalDatabaseCreatorDependencies;
     CanConnect(): boolean;
-    CanConnectAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    CanConnectAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     Create(): void;
     CreateAsync(cancellationToken?: CancellationToken): Task;
     CreateTables(): void;
@@ -1258,15 +1442,15 @@ export interface RelationalDatabaseCreator$instance {
     Delete(): void;
     DeleteAsync(cancellationToken?: CancellationToken): Task;
     EnsureCreated(): boolean;
-    EnsureCreatedAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    EnsureCreatedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     EnsureDeleted(): boolean;
-    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     Exists(): boolean;
-    ExistsAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    ExistsAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     GenerateCreateScript(): string;
-    GetCreateTablesCommands(options?: MigrationsSqlGenerationOptions): IReadOnlyList<MigrationCommand>;
+    GetCreateTablesCommands(options?: MigrationsSqlGenerationOptions): IReadOnlyList_1<MigrationCommand>;
     HasTables(): boolean;
-    HasTablesAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    HasTablesAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
 }
 
 
@@ -1279,12 +1463,14 @@ export interface __RelationalDatabaseCreator$views {
     As_IRelationalDatabaseCreator(): IRelationalDatabaseCreator$instance;
 }
 
-export interface RelationalDatabaseCreator$instance extends IRelationalDatabaseCreator$instance {}
-
 export type RelationalDatabaseCreator = RelationalDatabaseCreator$instance & __RelationalDatabaseCreator$views;
 
 
 export interface RelationalDatabaseCreatorDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalDatabaseCreatorDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     CommandLogger: IRelationalCommandDiagnosticsLogger;
     Connection: IRelationalConnection;
     ContextOptions: IDbContextOptions;
@@ -1311,6 +1497,10 @@ export const RelationalDatabaseCreatorDependencies: {
 export type RelationalDatabaseCreatorDependencies = RelationalDatabaseCreatorDependencies$instance;
 
 export interface RelationalDatabaseDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalDatabaseDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     BatchExecutor: IBatchExecutor;
     BatchPreparer: ICommandBatchPreparer;
     Connection: IRelationalConnection;
@@ -1330,6 +1520,11 @@ export const RelationalDatabaseDependencies: {
 export type RelationalDatabaseDependencies = RelationalDatabaseDependencies$instance;
 
 export interface RelationalDataReader$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalDataReader: never;
+
+    readonly __tsonic_iface_System_IAsyncDisposable: never;
+    readonly __tsonic_iface_System_IDisposable: never;
+
     readonly CommandId: Guid;
     readonly DbCommand: DbCommand;
     readonly DbDataReader: DbDataReader;
@@ -1340,7 +1535,7 @@ export interface RelationalDataReader$instance {
     DisposeAsync(): ValueTask;
     Initialize(relationalConnection: IRelationalConnection, command: DbCommand, reader: DbDataReader, commandId: Guid, logger: IRelationalCommandDiagnosticsLogger): void;
     Read(): boolean;
-    ReadAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    ReadAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
 }
 
 
@@ -1351,7 +1546,11 @@ export const RelationalDataReader: {
 
 export type RelationalDataReader = RelationalDataReader$instance;
 
-export interface RelationalExecutionStrategyFactory$instance {
+export interface RelationalExecutionStrategyFactory$instance extends IExecutionStrategyFactory$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalExecutionStrategyFactory: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategyFactory: never;
+
     readonly Dependencies: ExecutionStrategyDependencies;
     Create(): IExecutionStrategy;
     CreateDefaultStrategy(dependencies: ExecutionStrategyDependencies): IExecutionStrategy;
@@ -1367,17 +1566,17 @@ export interface __RelationalExecutionStrategyFactory$views {
     As_IExecutionStrategyFactory(): IExecutionStrategyFactory$instance;
 }
 
-export interface RelationalExecutionStrategyFactory$instance extends IExecutionStrategyFactory$instance {}
-
 export type RelationalExecutionStrategyFactory = RelationalExecutionStrategyFactory$instance & __RelationalExecutionStrategyFactory$views;
 
 
 export interface RelationalGeometryTypeMapping_2$instance<TGeometry, TProvider> extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalGeometryTypeMapping_2: never;
+
     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;
+    CreateParameter(command: DbCommand, name: string, value: unknown, nullable?: Nullable_1<System_Internal.Boolean>, direction?: ParameterDirection): DbParameter;
+    CreateParameter(command: DbCommand, name: string, value: unknown, nullable?: Nullable_1<System_Internal.Boolean>, direction?: ParameterDirection): DbParameter;
     CustomizeDataReaderExpression(expression: Expression): Expression;
     GenerateCodeLiteral(value: unknown): Expression;
     GetSrid(value: unknown): int;
@@ -1391,6 +1590,10 @@ export const RelationalGeometryTypeMapping_2: (abstract new<TGeometry, TProvider
 export type RelationalGeometryTypeMapping_2<TGeometry, TProvider> = RelationalGeometryTypeMapping_2$instance<TGeometry, TProvider>;
 
 export interface RelationalSqlGenerationHelper$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalSqlGenerationHelper: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ISqlGenerationHelper: never;
+
     readonly BatchTerminator: string;
     readonly CommitTransactionStatement: string;
     readonly Dependencies: RelationalSqlGenerationHelperDependencies;
@@ -1429,6 +1632,10 @@ export type RelationalSqlGenerationHelper = RelationalSqlGenerationHelper$instan
 
 
 export interface RelationalSqlGenerationHelperDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalSqlGenerationHelperDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     _Clone_$(): RelationalSqlGenerationHelperDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: RelationalSqlGenerationHelperDependencies): boolean;
@@ -1445,6 +1652,13 @@ export const RelationalSqlGenerationHelperDependencies: {
 export type RelationalSqlGenerationHelperDependencies = RelationalSqlGenerationHelperDependencies$instance;
 
 export interface RelationalTransaction$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTransaction: never;
+
+    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;
+
     readonly Connection: IRelationalConnection;
     readonly Logger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>;
     readonly SupportsSavepoints: boolean;
@@ -1476,12 +1690,14 @@ export interface __RelationalTransaction$views {
     As_IDbContextTransaction(): IDbContextTransaction$instance;
 }
 
-export interface RelationalTransaction$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IInfrastructure_1$instance<DbTransaction>, IDbContextTransaction$instance {}
-
 export type RelationalTransaction = RelationalTransaction$instance & __RelationalTransaction$views;
 
 
-export interface RelationalTransactionFactory$instance {
+export interface RelationalTransactionFactory$instance extends IRelationalTransactionFactory$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTransactionFactory: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTransactionFactory: never;
+
     readonly Dependencies: RelationalTransactionFactoryDependencies;
     Create(connection: IRelationalConnection, transaction: DbTransaction, transactionId: Guid, logger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>, transactionOwned: boolean): RelationalTransaction;
 }
@@ -1496,12 +1712,14 @@ export interface __RelationalTransactionFactory$views {
     As_IRelationalTransactionFactory(): IRelationalTransactionFactory$instance;
 }
 
-export interface RelationalTransactionFactory$instance extends IRelationalTransactionFactory$instance {}
-
 export type RelationalTransactionFactory = RelationalTransactionFactory$instance & __RelationalTransactionFactory$views;
 
 
 export interface RelationalTransactionFactoryDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTransactionFactoryDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     SqlGenerationHelper: ISqlGenerationHelper;
     _Clone_$(): RelationalTransactionFactoryDependencies;
     Equals(obj: unknown): boolean;
@@ -1519,23 +1737,25 @@ export const RelationalTransactionFactoryDependencies: {
 export type RelationalTransactionFactoryDependencies = RelationalTransactionFactoryDependencies$instance;
 
 export interface RelationalTypeMapping$instance extends CoreTypeMapping {
-    readonly DbType: Nullable<DbType>;
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTypeMapping: never;
+
+    readonly DbType: Nullable_1<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 Precision: Nullable_1<System_Internal.Int32>;
+    readonly Scale: Nullable_1<System_Internal.Int32>;
+    readonly Size: Nullable_1<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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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;
+    CreateParameter(command: DbCommand, name: string, value: unknown, nullable?: Nullable_1<System_Internal.Boolean>, direction?: ParameterDirection): DbParameter;
     CustomizeDataReaderExpression(expression: Expression): Expression;
     GenerateNonNullSqlLiteral(value: unknown): string;
     GenerateProviderValueSqlLiteral(value: unknown): string;
@@ -1543,13 +1763,13 @@ export interface RelationalTypeMapping$instance extends CoreTypeMapping {
     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;
+    WithPrecisionAndScale(precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): RelationalTypeMapping;
+    WithStoreTypeAndSize(storeType: string, size: Nullable_1<System_Internal.Int32>): RelationalTypeMapping;
     WithTypeMappingInfo(mappingInfo: RelationalTypeMappingInfo): 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) & {
+export const RelationalTypeMapping: (abstract new(parameters: unknown) => RelationalTypeMapping) & (abstract new(storeType: string, clrType: Type, dbType: Nullable_1<DbType>, unicode: boolean, size: Nullable_1<System_Internal.Int32>, fixedLength: boolean, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>, jsonValueReaderWriter: JsonValueReaderWriter) => RelationalTypeMapping) & {
     readonly NullMapping: RelationalTypeMapping;
     GetDataReaderMethod(type: Type): MethodInfo;
 };
@@ -1558,6 +1778,11 @@ export const RelationalTypeMapping: (abstract new(parameters: unknown) => Relati
 export type RelationalTypeMapping = RelationalTypeMapping$instance;
 
 export interface RelationalTypeMappingSource$instance extends TypeMappingSourceBase$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTypeMappingSource: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTypeMappingSource: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSource: never;
+
     readonly RelationalDependencies: RelationalTypeMappingSourceDependencies;
     FindCollectionMapping(info: RelationalTypeMappingInfo, modelType: Type, providerType: Type, elementMapping: CoreTypeMapping): RelationalTypeMapping | undefined;
     FindMapping(mappingInfo: RelationalTypeMappingInfo): RelationalTypeMapping | undefined;
@@ -1572,7 +1797,7 @@ export interface RelationalTypeMappingSource$instance extends TypeMappingSourceB
     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;
+    ParseStoreTypeName(storeTypeName: string, unicode: Nullable_1<System_Internal.Boolean>, size: Nullable_1<System_Internal.Int32>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): string | undefined;
 }
 
 
@@ -1589,7 +1814,11 @@ export type RelationalTypeMappingSource = RelationalTypeMappingSource$instance &
 
 
 export interface RelationalTypeMappingSourceDependencies$instance {
-    Plugins: IEnumerable<IRelationalTypeMappingSourcePlugin>;
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTypeMappingSourceDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
+    Plugins: IEnumerable_1<IRelationalTypeMappingSourcePlugin>;
     _Clone_$(): RelationalTypeMappingSourceDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: RelationalTypeMappingSourceDependencies): boolean;
@@ -1599,13 +1828,17 @@ export interface RelationalTypeMappingSourceDependencies$instance {
 
 
 export const RelationalTypeMappingSourceDependencies: {
-    new(plugins: IEnumerable<IRelationalTypeMappingSourcePlugin>): RelationalTypeMappingSourceDependencies;
+    new(plugins: IEnumerable_1<IRelationalTypeMappingSourcePlugin>): RelationalTypeMappingSourceDependencies;
 };
 
 
 export type RelationalTypeMappingSourceDependencies = RelationalTypeMappingSourceDependencies$instance;
 
 export interface RetryLimitExceededException$instance extends Exception {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RetryLimitExceededException: never;
+
+    readonly __tsonic_iface_System_Runtime_Serialization_ISerializable: never;
+
 }
 
 
@@ -1620,15 +1853,17 @@ export const RetryLimitExceededException: {
 export type RetryLimitExceededException = RetryLimitExceededException$instance;
 
 export interface SByteTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_SByteTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): SByteTypeMapping;
     readonly Default: SByteTypeMapping;
 };
 
@@ -1636,15 +1871,17 @@ export const SByteTypeMapping: {
 export type SByteTypeMapping = SByteTypeMapping$instance;
 
 export interface ShortTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ShortTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): ShortTypeMapping;
     readonly Default: ShortTypeMapping;
 };
 
@@ -1652,17 +1889,19 @@ export const ShortTypeMapping: {
 export type ShortTypeMapping = ShortTypeMapping$instance;
 
 export interface StringTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_StringTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>, unicode: boolean, size: Nullable_1<System_Internal.Int32>): StringTypeMapping;
     readonly Default: StringTypeMapping;
 };
 
@@ -1670,16 +1909,18 @@ export const StringTypeMapping: {
 export type StringTypeMapping = StringTypeMapping$instance;
 
 export interface TimeOnlyTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TimeOnlyTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): TimeOnlyTypeMapping;
     readonly Default: TimeOnlyTypeMapping;
 };
 
@@ -1687,16 +1928,18 @@ export const TimeOnlyTypeMapping: {
 export type TimeOnlyTypeMapping = TimeOnlyTypeMapping$instance;
 
 export interface TimeSpanTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TimeSpanTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): TimeSpanTypeMapping;
     readonly Default: TimeSpanTypeMapping;
 };
 
@@ -1704,6 +1947,10 @@ export const TimeSpanTypeMapping: {
 export type TimeSpanTypeMapping = TimeSpanTypeMapping$instance;
 
 export interface TypeMappingSource$instance extends TypeMappingSourceBase$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TypeMappingSource: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSource: never;
+
     FindCollectionMapping(info: TypeMappingInfo, modelType: Type, providerType: Type, elementMapping: CoreTypeMapping): CoreTypeMapping | undefined;
     FindMapping(property: IProperty): CoreTypeMapping | undefined;
     FindMapping(elementType: IElementType): CoreTypeMapping | undefined;
@@ -1727,6 +1974,10 @@ export type TypeMappingSource = TypeMappingSource$instance & __TypeMappingSource
 
 
 export interface TypeMappingSourceBase$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TypeMappingSourceBase: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSource: never;
+
     readonly Dependencies: TypeMappingSourceDependencies;
     FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping | undefined;
     FindMapping(property: IProperty): CoreTypeMapping | undefined;
@@ -1752,8 +2003,12 @@ export type TypeMappingSourceBase = TypeMappingSourceBase$instance & __TypeMappi
 
 
 export interface TypeMappingSourceDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TypeMappingSourceDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     readonly JsonValueReaderWriterSource: IJsonValueReaderWriterSource;
-    Plugins: IEnumerable<ITypeMappingSourcePlugin>;
+    Plugins: IEnumerable_1<ITypeMappingSourcePlugin>;
     ValueConverterSelector: IValueConverterSelector;
     _Clone_$(): TypeMappingSourceDependencies;
     Equals(obj: unknown): boolean;
@@ -1764,14 +2019,16 @@ export interface TypeMappingSourceDependencies$instance {
 
 
 export const TypeMappingSourceDependencies: {
-    new(valueConverterSelector: IValueConverterSelector, jsonValueReaderWriterSource: IJsonValueReaderWriterSource, plugins: IEnumerable<ITypeMappingSourcePlugin>): TypeMappingSourceDependencies;
+    new(valueConverterSelector: IValueConverterSelector, jsonValueReaderWriterSource: IJsonValueReaderWriterSource, plugins: IEnumerable_1<ITypeMappingSourcePlugin>): TypeMappingSourceDependencies;
 };
 
 
 export type TypeMappingSourceDependencies = TypeMappingSourceDependencies$instance;
 
 export interface TypeMaterializationInfo$instance {
-    readonly IsNullable: Nullable<System_Internal.Boolean>;
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TypeMaterializationInfo: never;
+
+    readonly IsNullable: Nullable_1<System_Internal.Boolean>;
     readonly Mapping: RelationalTypeMapping;
     readonly ModelClrType: Type;
     readonly Property: IProperty | undefined;
@@ -1783,22 +2040,24 @@ export interface TypeMaterializationInfo$instance {
 
 
 export const TypeMaterializationInfo: {
-    new(modelClrType: Type, property: IProperty, mapping: RelationalTypeMapping, nullable: Nullable<System_Internal.Boolean>): TypeMaterializationInfo;
+    new(modelClrType: Type, property: IProperty, mapping: RelationalTypeMapping, nullable: Nullable_1<System_Internal.Boolean>): TypeMaterializationInfo;
 };
 
 
 export type TypeMaterializationInfo = TypeMaterializationInfo$instance;
 
 export interface UIntTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_UIntTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): UIntTypeMapping;
     readonly Default: UIntTypeMapping;
 };
 
@@ -1806,15 +2065,17 @@ export const UIntTypeMapping: {
 export type UIntTypeMapping = UIntTypeMapping$instance;
 
 export interface ULongTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ULongTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): ULongTypeMapping;
     readonly Default: ULongTypeMapping;
 };
 
@@ -1822,15 +2083,17 @@ export const ULongTypeMapping: {
 export type ULongTypeMapping = ULongTypeMapping$instance;
 
 export interface UShortTypeMapping$instance extends RelationalTypeMapping {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_UShortTypeMapping: never;
+
     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;
+    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type, converter?: ValueConverter, comparer?: ValueComparer, keyComparer?: ValueComparer, providerValueComparer?: ValueComparer, elementMapping?: CoreTypeMapping, jsonValueReaderWriter?: JsonValueReaderWriter, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
+    Clone(mappingInfo?: Nullable_1<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(storeType: string, dbType: Nullable_1<DbType>): UShortTypeMapping;
     readonly Default: UShortTypeMapping;
 };
 
@@ -1845,8 +2108,8 @@ export abstract class DbContextTransactionExtensions$instance {
 export type DbContextTransactionExtensions = DbContextTransactionExtensions$instance;
 
 export abstract class RelationalCommandBuilderExtensions$instance {
-    static AddCompositeParameter(commandBuilder: IRelationalCommandBuilder, invariantName: string, subParameters: IReadOnlyList<IRelationalParameter>): IRelationalCommandBuilder;
-    static AddParameter(commandBuilder: IRelationalCommandBuilder, invariantName: string, name: string, relationalTypeMapping: RelationalTypeMapping, nullable: Nullable<System_Internal.Boolean>, direction?: ParameterDirection): IRelationalCommandBuilder;
+    static AddCompositeParameter(commandBuilder: IRelationalCommandBuilder, invariantName: string, subParameters: IReadOnlyList_1<IRelationalParameter>): IRelationalCommandBuilder;
+    static AddParameter(commandBuilder: IRelationalCommandBuilder, invariantName: string, name: string, relationalTypeMapping: RelationalTypeMapping, nullable: Nullable_1<System_Internal.Boolean>, direction?: ParameterDirection): IRelationalCommandBuilder;
     static AddParameter(commandBuilder: IRelationalCommandBuilder, invariantName: string, name: string): IRelationalCommandBuilder;
     static AddRawParameter(commandBuilder: IRelationalCommandBuilder, invariantName: string, dbParameter: DbParameter): IRelationalCommandBuilder;
     static AppendLine(commandBuilder: IRelationalCommandBuilder, value: FormattableString): IRelationalCommandBuilder;
@@ -1859,15 +2122,15 @@ export abstract class RelationalCommandBuilderExtensions$instance {
 export type RelationalCommandBuilderExtensions = RelationalCommandBuilderExtensions$instance;
 
 export abstract class RelationalExecutionStrategyExtensions$instance {
-    static ExecuteInTransaction<TResult>(strategy: IExecutionStrategy, operation: Func<TResult>, verifySucceeded: Func<System_Internal.Boolean>, isolationLevel: IsolationLevel): TResult;
-    static ExecuteInTransaction(strategy: IExecutionStrategy, operation: Action, verifySucceeded: Func<System_Internal.Boolean>, isolationLevel: IsolationLevel): void;
-    static ExecuteInTransaction<TState>(strategy: IExecutionStrategy, state: TState, operation: Action<TState>, verifySucceeded: Func<TState, System_Internal.Boolean>, isolationLevel: IsolationLevel): void;
-    static ExecuteInTransaction<TState, TResult>(strategy: IExecutionStrategy, state: TState, operation: Func<TState, TResult>, verifySucceeded: Func<TState, System_Internal.Boolean>, isolationLevel: IsolationLevel): TResult;
-    static ExecuteInTransactionAsync<TResult>(strategy: IExecutionStrategy, operation: Func<CancellationToken, Task<TResult>>, verifySucceeded: Func<CancellationToken, Task<System_Internal.Boolean>>, isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task<TResult>;
-    static ExecuteInTransactionAsync(strategy: IExecutionStrategy, operation: Func<Task>, verifySucceeded: Func<Task<System_Internal.Boolean>>, isolationLevel: IsolationLevel): Task;
-    static ExecuteInTransactionAsync(strategy: IExecutionStrategy, operation: Func<CancellationToken, Task>, verifySucceeded: Func<CancellationToken, Task<System_Internal.Boolean>>, isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task;
-    static ExecuteInTransactionAsync<TState>(strategy: IExecutionStrategy, state: TState, operation: Func<TState, CancellationToken, Task>, verifySucceeded: Func<TState, CancellationToken, Task<System_Internal.Boolean>>, isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task;
-    static ExecuteInTransactionAsync<TState, TResult>(strategy: IExecutionStrategy, state: TState, operation: Func<TState, CancellationToken, Task<TResult>>, verifySucceeded: Func<TState, CancellationToken, Task<System_Internal.Boolean>>, isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task<TResult>;
+    static ExecuteInTransaction<TResult>(strategy: IExecutionStrategy, operation: Func_1<TResult>, verifySucceeded: Func_1<System_Internal.Boolean>, isolationLevel: IsolationLevel): TResult;
+    static ExecuteInTransaction(strategy: IExecutionStrategy, operation: Action, verifySucceeded: Func_1<System_Internal.Boolean>, isolationLevel: IsolationLevel): void;
+    static ExecuteInTransaction<TState>(strategy: IExecutionStrategy, state: TState, operation: Action_1<TState>, verifySucceeded: Func_2<TState, System_Internal.Boolean>, isolationLevel: IsolationLevel): void;
+    static ExecuteInTransaction<TState, TResult>(strategy: IExecutionStrategy, state: TState, operation: Func_2<TState, TResult>, verifySucceeded: Func_2<TState, System_Internal.Boolean>, isolationLevel: IsolationLevel): TResult;
+    static ExecuteInTransactionAsync<TResult>(strategy: IExecutionStrategy, operation: Func_2<CancellationToken, Task_1<TResult>>, verifySucceeded: Func_2<CancellationToken, Task_1<System_Internal.Boolean>>, isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task_1<TResult>;
+    static ExecuteInTransactionAsync(strategy: IExecutionStrategy, operation: Func_1<Task>, verifySucceeded: Func_1<Task_1<System_Internal.Boolean>>, isolationLevel: IsolationLevel): Task;
+    static ExecuteInTransactionAsync(strategy: IExecutionStrategy, operation: Func_2<CancellationToken, Task>, verifySucceeded: Func_2<CancellationToken, Task_1<System_Internal.Boolean>>, isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task;
+    static ExecuteInTransactionAsync<TState>(strategy: IExecutionStrategy, state: TState, operation: Func_3<TState, CancellationToken, Task>, verifySucceeded: Func_3<TState, CancellationToken, Task_1<System_Internal.Boolean>>, isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task;
+    static ExecuteInTransactionAsync<TState, TResult>(strategy: IExecutionStrategy, state: TState, operation: Func_3<TState, CancellationToken, Task_1<TResult>>, verifySucceeded: Func_3<TState, CancellationToken, Task_1<System_Internal.Boolean>>, isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task_1<TResult>;
 }