// Generated by tsbindgen - Architecture
// Namespace: Microsoft.EntityFrameworkCore.Storage
// Assembly: Microsoft.EntityFrameworkCore, Microsoft.EntityFrameworkCore.Relational

// Core type aliases from @tsonic/core
import type { fnptr, ptr, sbyte, byte, short, ushort, int, uint, long, ulong, int128, uint128, half, float, double, decimal, nint, nuint, char } from '@tsonic/core/types.js';


// Import types from other namespaces
import type { ValueComparer } from "../../Microsoft.EntityFrameworkCore.ChangeTracking/internal/index.js";
import type { CommandSource, DbCommandMethod, IDiagnosticsLogger_1, ILoggingOptions, IRelationalCommandDiagnosticsLogger, IRelationalConnectionDiagnosticsLogger } from "../../Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
import * as Microsoft_EntityFrameworkCore_Infrastructure_Internal from "../../Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
import type { IConcurrencyDetector, ICoreSingletonOptions, ICurrentDbContext, IDbContextOptions, IDbContextOptionsExtension, IInfrastructure_1, IResettableService } from "../../Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
import type { IAdHocMapper, IElementType, IEntityType, IModel, IProperty, IPropertyBase, ITypeBase, ITypeMappingConfiguration } from "../../Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
import type { IMigrationCommandExecutor, IMigrationsModelDiffer, IMigrationsSqlGenerator, MigrationCommand, MigrationsSqlGenerationOptions } from "../../Microsoft.EntityFrameworkCore.Migrations/internal/index.js";
import type { IAsyncQueryProvider, IQueryCompilationContextFactory, QueryContext } from "../../Microsoft.EntityFrameworkCore.Query/internal/index.js";
import type { INamedConnectionStringResolver } from "../../Microsoft.EntityFrameworkCore.Storage.Internal/internal/index.js";
import type { IJsonValueReaderWriterSource, JsonValueReaderWriter } from "../../Microsoft.EntityFrameworkCore.Storage.Json/internal/index.js";
import type { IValueConverterSelector, ValueConverter, ValueConverter_2, ValueConverterInfo } from "../../Microsoft.EntityFrameworkCore.Storage.ValueConversion/internal/index.js";
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_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,
    Size = 1,
    Precision = 2,
    PrecisionAndScale = 3
}


export interface IDatabase$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabase: never;

    CompileQuery<TResult extends unknown>(query: Expression, async: boolean): Func_2<QueryContext, TResult>;
    CompileQueryExpression<TResult extends unknown>(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_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_1<IDatabaseProvider>;
    readonly CommandLogger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Command>;
    readonly ConcurrencyDetector: IConcurrencyDetector;
    readonly CoreOptions: ICoreSingletonOptions;
    readonly QueryProvider: IAsyncQueryProvider;
    readonly AdHocMapper: IAdHocMapper;
    readonly TypeMappingSource: ITypeMappingSource;
}


export type IDatabaseFacadeDependencies = IDatabaseFacadeDependencies$instance;

export interface IDatabaseFacadeDependenciesAccessor$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseFacadeDependenciesAccessor: never;

    readonly Dependencies: IDatabaseFacadeDependencies;
    readonly Context: DbContext;
}


export type IDatabaseFacadeDependenciesAccessor = IDatabaseFacadeDependenciesAccessor$instance;

export interface IDatabaseProvider$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseProvider: never;

    readonly Name: string;
    readonly Version: string | null;
    IsConfigured(options: IDbContextOptions): boolean;
}


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;
    CommitAsync(cancellationToken?: CancellationToken): Task;
    CreateSavepoint(name: string): void;
    CreateSavepointAsync(name: string, cancellationToken?: CancellationToken): Task;
}


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 | null;
    BeginTransaction(): IDbContextTransaction;
    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
    CommitTransaction(): void;
    CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
    ResetState(): void;
    ResetStateAsync(cancellationToken?: CancellationToken): Task;
}


export interface IDbContextTransactionManager$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IResettableService$instance {}

export type IDbContextTransactionManager = IDbContextTransactionManager$instance;

export interface IExceptionDetector$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExceptionDetector: never;

    IsCancellation(exception: Exception, cancellationToken?: CancellationToken): boolean;
}


export type IExceptionDetector = IExceptionDetector$instance;

export interface IExecutionStrategy$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategy: never;

    readonly RetriesOnFailure: boolean;
    Execute<TState extends unknown, TResult extends unknown>(state: TState, operation: Func_3<DbContext, TState, TResult>, verifySucceeded: Func_3<DbContext, TState, ExecutionResult_1<TResult>> | null): TResult;
    ExecuteAsync<TState extends unknown, TResult extends unknown>(state: TState, operation: Func_4<DbContext, TState, CancellationToken, Task_1<TResult>>, verifySucceeded: Func_4<DbContext, TState, CancellationToken, Task_1<ExecutionResult_1<TResult>>> | null, cancellationToken?: CancellationToken): Task_1<TResult>;
}


export type IExecutionStrategy = IExecutionStrategy$instance;

export interface IExecutionStrategyFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IExecutionStrategyFactory: never;

    Create(): IExecutionStrategy;
}


export type IExecutionStrategyFactory = IExecutionStrategyFactory$instance;

export interface IParameterNameGeneratorFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IParameterNameGeneratorFactory: never;

    Create(): ParameterNameGenerator;
}


export type IParameterNameGeneratorFactory = IParameterNameGeneratorFactory$instance;

export interface IRawSqlCommandBuilder$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRawSqlCommandBuilder: never;

    Build(sql: string, parameters: IEnumerable_1<unknown | null>, model: IModel): RawSqlCommand;
    Build(sql: string, parameters: IEnumerable_1<unknown | null>): RawSqlCommand;
    Build(sql: string): IRelationalCommand;
}


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_1<IRelationalParameter>;
    CreateDbCommand(parameterObject: RelationalCommandParameterObject, commandId: Guid, commandMethod: DbCommandMethod): DbCommand;
    ExecuteNonQuery(parameterObject: RelationalCommandParameterObject): int;
    ExecuteNonQueryAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
    ExecuteReader(parameterObject: RelationalCommandParameterObject): RelationalDataReader;
    ExecuteScalar(parameterObject: RelationalCommandParameterObject): unknown | null;
    PopulateFrom(commandTemplate: IRelationalCommandTemplate): void;
}


export interface IRelationalCommand$instance extends IRelationalCommandTemplate$instance {}

export type IRelationalCommand = IRelationalCommand$instance;

export interface IRelationalCommandBuilder$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilder: never;

    readonly Parameters: IReadOnlyList_1<IRelationalParameter>;
    readonly TypeMappingSource: IRelationalTypeMappingSource;
    readonly CommandTextLength: int;
    AddParameter(parameter: IRelationalParameter): IRelationalCommandBuilder;
    Append(value: FormattableString, sensitive?: boolean): IRelationalCommandBuilder;
    Append(value: string, sensitive?: boolean): IRelationalCommandBuilder;
    AppendLine(): IRelationalCommandBuilder;
    Build(): IRelationalCommand;
    RemoveParameterAt(index: int): IRelationalCommandBuilder;
}


export type IRelationalCommandBuilder = IRelationalCommandBuilder$instance;

export interface IRelationalCommandBuilderFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalCommandBuilderFactory: never;

    Create(): IRelationalCommandBuilder;
}


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_1<IRelationalParameter>;
    CreateDbCommand(parameterObject: RelationalCommandParameterObject, commandId: Guid, commandMethod: DbCommandMethod): DbCommand;
}


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 | null;
    set ConnectionString(value: string | null);
    DbConnection: DbConnection;
    readonly Context: DbContext;
    readonly ConnectionId: Guid;
    get CommandTimeout(): Nullable_1<System_Internal.Int32>;
    set CommandTimeout(value: Nullable_1<System_Internal.Int32> | int);
    readonly CurrentTransaction: IDbContextTransaction | null;
    BeginTransaction(): IDbContextTransaction;
    BeginTransaction(isolationLevel: IsolationLevel): IDbContextTransaction;
    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
    Close(): boolean;
    CloseAsync(): Task_1<System_Internal.Boolean>;
    CommitTransaction(): void;
    CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
    Open(errorsExpected?: boolean): boolean;
    OpenAsync(cancellationToken: CancellationToken, errorsExpected?: boolean): Task_1<System_Internal.Boolean>;
    RentCommand(): IRelationalCommand;
    ReturnCommand(command: IRelationalCommand): void;
    SetDbConnection(value: DbConnection | null, contextOwnsConnection: boolean): void;
    UseTransaction(transaction: DbTransaction | null, transactionId: Guid): IDbContextTransaction | null;
    UseTransaction(transaction: DbTransaction | null): IDbContextTransaction | null;
    UseTransactionAsync(transaction: DbTransaction | null, transactionId: Guid, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | null>;
    UseTransactionAsync(transaction: DbTransaction | null, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | null>;
    ResetState(): void;
    ResetStateAsync(cancellationToken?: CancellationToken): Task;
}


export interface IRelationalConnection$instance extends IRelationalTransactionManager$instance, 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_1<System_Internal.Boolean>;
    GenerateCreateScript(): string;
    EnsureDeleted(): boolean;
    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
}


export interface IRelationalDatabaseCreator$instance extends IDatabaseCreator$instance {}

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;
    readonly TransactionManager: IDbContextTransactionManager;
    readonly DatabaseCreator: IDatabaseCreator;
    readonly ExecutionStrategy: IExecutionStrategy;
    readonly ExecutionStrategyFactory: IExecutionStrategyFactory;
    readonly DatabaseProviders: IEnumerable_1<IDatabaseProvider>;
    readonly ConcurrencyDetector: IConcurrencyDetector;
    readonly CoreOptions: ICoreSingletonOptions;
    readonly QueryProvider: IAsyncQueryProvider;
    readonly AdHocMapper: IAdHocMapper;
    readonly TypeMappingSource: ITypeMappingSource;
}


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_2<System_Internal.String, unknown | null> | null): void;
    AddDbParameter(command: DbCommand, value: unknown | null): void;
}


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;
}


export type IRelationalTransactionFactory = IRelationalTransactionFactory$instance;

export interface IRelationalTransactionManager$instance extends IDbContextTransactionManager, IResettableService {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTransactionManager: never;

    readonly CurrentTransaction: IDbContextTransaction | null;
    BeginTransaction(): IDbContextTransaction;
    BeginTransaction(isolationLevel: IsolationLevel): IDbContextTransaction;
    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
    CommitTransaction(): void;
    CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
    UseTransaction(transaction: DbTransaction | null, transactionId: Guid): IDbContextTransaction | null;
    UseTransaction(transaction: DbTransaction | null): IDbContextTransaction | null;
    UseTransactionAsync(transaction: DbTransaction | null, transactionId: Guid, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | null>;
    UseTransactionAsync(transaction: DbTransaction | null, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | null>;
    ResetState(): void;
    ResetStateAsync(cancellationToken?: CancellationToken): Task;
}


export type IRelationalTransactionManager = IRelationalTransactionManager$instance;

export interface IRelationalTypeMappingSource$instance extends ITypeMappingSource {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTypeMappingSource: never;

    FindMapping(elementType: IElementType): CoreTypeMapping | null;
    FindMapping(property: IProperty): CoreTypeMapping | null;
    FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | null;
    FindMapping(member: MemberInfo): CoreTypeMapping | null;
    FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping | null): CoreTypeMapping | null;
    FindMapping(type: Type): CoreTypeMapping | null;
    FindMapping(property: IProperty): RelationalTypeMapping | null;
    FindMapping(member: MemberInfo): RelationalTypeMapping | null;
    FindMapping(storeTypeName: string): RelationalTypeMapping | null;
    FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping | null): RelationalTypeMapping | null;
    FindMapping(type: Type, storeTypeName: string | null, 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 | null;
    FindMapping(type: Type): RelationalTypeMapping | null;
}


export type IRelationalTypeMappingSource = IRelationalTypeMappingSource$instance;

export interface IRelationalTypeMappingSourcePlugin$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IRelationalTypeMappingSourcePlugin: never;

    FindMapping(mappingInfo: RelationalTypeMappingInfo): RelationalTypeMapping | null;
}


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;
    readonly CommitTransactionStatement: string;
    readonly SingleLineCommentToken: string;
    DelimitIdentifier(name: string, schema: string | null): string;
    DelimitIdentifier(builder: StringBuilder, name: string, schema: string | null): void;
    GenerateParameterName(name: string): string;
    GenerateParameterName(builder: StringBuilder, name: string): void;
}


export type ISqlGenerationHelper = ISqlGenerationHelper$instance;

export interface ITransactionEnlistmentManager$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITransactionEnlistmentManager: never;

    readonly CurrentAmbientTransaction: Transaction | null;
    readonly EnlistedTransaction: Transaction | null;
    EnlistTransaction(transaction: Transaction | null): void;
}


export type ITransactionEnlistmentManager = ITransactionEnlistmentManager$instance;

export interface ITypeMappingSource$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSource: never;

    FindMapping(elementType: IElementType): CoreTypeMapping | null;
    FindMapping(property: IProperty): CoreTypeMapping | null;
    FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | null;
    FindMapping(member: MemberInfo): CoreTypeMapping | null;
    FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping | null): CoreTypeMapping | null;
    FindMapping(type: Type): CoreTypeMapping | null;
}


export type ITypeMappingSource = ITypeMappingSource$instance;

export interface ITypeMappingSourcePlugin$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_ITypeMappingSourcePlugin: never;

    FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping | null;
}


export type ITypeMappingSourcePlugin = ITypeMappingSourcePlugin$instance;

export interface MaterializationContext$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_MaterializationContext: never;

    readonly Context: DbContext;
    readonly ValueBuffer: ValueBuffer;
}


export const MaterializationContext: {
    new(valueBuffer: ValueBuffer, context: DbContext): MaterializationContext;
    readonly GetValueBufferMethod: MethodInfo;
};


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 | null;
    readonly DetailedErrorsEnabled: boolean;
    readonly Logger: IRelationalCommandDiagnosticsLogger | null;
    readonly ParameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | null> | null;
    readonly ReaderColumns: IReadOnlyList_1<ReaderColumn | null> | null;
    Equals(obj: unknown): boolean;
    Equals(other: RelationalCommandParameterObject): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalCommandParameterObject: {
    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | null> | null, readerColumns: IReadOnlyList_1<ReaderColumn> | null, context: DbContext | null, logger: IRelationalCommandDiagnosticsLogger | null): RelationalCommandParameterObject;
    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | null> | null, readerColumns: IReadOnlyList_1<ReaderColumn> | null, context: DbContext | null, logger: IRelationalCommandDiagnosticsLogger | null, commandSource: CommandSource): RelationalCommandParameterObject;
    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | null> | null, readerColumns: IReadOnlyList_1<ReaderColumn> | null, context: DbContext | null, logger: IRelationalCommandDiagnosticsLogger | null, detailedErrorsEnabled: boolean): RelationalCommandParameterObject;
    new(connection: IRelationalConnection, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | null> | null, readerColumns: IReadOnlyList_1<ReaderColumn | null> | null, context: DbContext | null, logger: IRelationalCommandDiagnosticsLogger | null, 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 | null;
    set ClrType(value: Type | null);
    readonly CoreTypeMappingInfo: TypeMappingInfo;
    get DbType(): Nullable_1<DbType>;
    set DbType(value: Nullable_1<DbType> | DbType);
    get ElementTypeMapping(): RelationalTypeMapping | null;
    set ElementTypeMapping(value: RelationalTypeMapping | null);
    get IsFixedLength(): Nullable_1<System_Internal.Boolean>;
    set IsFixedLength(value: Nullable_1<System_Internal.Boolean> | boolean);
    IsKey: boolean;
    IsKeyOrIndex: boolean;
    get IsRowVersion(): Nullable_1<System_Internal.Boolean>;
    set IsRowVersion(value: Nullable_1<System_Internal.Boolean> | boolean);
    get IsUnicode(): Nullable_1<System_Internal.Boolean>;
    set IsUnicode(value: Nullable_1<System_Internal.Boolean> | boolean);
    get JsonValueReaderWriter(): JsonValueReaderWriter | null;
    set JsonValueReaderWriter(value: JsonValueReaderWriter | null);
    get Precision(): Nullable_1<System_Internal.Int32>;
    set Precision(value: Nullable_1<System_Internal.Int32> | int);
    get Scale(): Nullable_1<System_Internal.Int32>;
    set Scale(value: Nullable_1<System_Internal.Int32> | int);
    get Size(): Nullable_1<System_Internal.Int32>;
    set Size(value: Nullable_1<System_Internal.Int32> | int);
    get StoreTypeName(): string | null;
    set StoreTypeName(value: string | null);
    get StoreTypeNameBase(): string | null;
    set StoreTypeNameBase(value: string | null);
    Equals(obj: unknown): boolean;
    Equals(other: RelationalTypeMappingInfo): boolean;
    GetHashCode(): int;
    ToString(): string;
    WithConverter(converterInfo: ValueConverterInfo): RelationalTypeMappingInfo;
}


export const RelationalTypeMappingInfo: {
    new(property: IProperty): RelationalTypeMappingInfo;
    new(elementType: IElementType, storeTypeName: string | null, storeTypeNameBase: string | null, 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 | null, storeTypeNameBase: string | null, 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 | null, storeTypeName: string | null, storeTypeNameBase: string | null, 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 | null, elementTypeMapping: RelationalTypeMapping | null, storeTypeName: string | null, storeTypeNameBase: string | null, 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 | null, storeTypeName: string | null, storeTypeNameBase: string | null, 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 | null;
    set ClrType(value: Type | null);
    get ElementTypeMapping(): CoreTypeMapping | null;
    set ElementTypeMapping(value: CoreTypeMapping | null);
    IsKey: boolean;
    IsKeyOrIndex: boolean;
    get IsRowVersion(): Nullable_1<System_Internal.Boolean>;
    set IsRowVersion(value: Nullable_1<System_Internal.Boolean> | boolean);
    get IsUnicode(): Nullable_1<System_Internal.Boolean>;
    set IsUnicode(value: Nullable_1<System_Internal.Boolean> | boolean);
    get JsonValueReaderWriter(): JsonValueReaderWriter | null;
    set JsonValueReaderWriter(value: JsonValueReaderWriter | null);
    get Precision(): Nullable_1<System_Internal.Int32>;
    set Precision(value: Nullable_1<System_Internal.Int32> | int);
    get Scale(): Nullable_1<System_Internal.Int32>;
    set Scale(value: Nullable_1<System_Internal.Int32> | int);
    get Size(): Nullable_1<System_Internal.Int32>;
    set Size(value: Nullable_1<System_Internal.Int32> | int);
    Equals(obj: unknown): boolean;
    Equals(other: TypeMappingInfo): boolean;
    GetHashCode(): int;
    ToString(): string;
    WithConverter(converterInfo: ValueConverterInfo): TypeMappingInfo;
}


export const TypeMappingInfo: {
    new(property: IProperty): 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 | null, 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 | null): TypeMappingInfo;
    new(type: Type | null, elementTypeMapping: CoreTypeMapping | null, 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;
    Equals(obj: unknown | null): boolean;
    Equals(other: ValueBuffer): boolean;
    GetHashCode(): int;
}


export const ValueBuffer: {
    new(values: (unknown | null)[]): ValueBuffer;
    readonly Empty: ValueBuffer;
};


export type ValueBuffer = ValueBuffer$instance & { [index: number]: unknown | null; };

export interface BoolTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_BoolTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    GenerateNonNullSqlLiteral(value: unknown): string;
}


export const BoolTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): BoolTypeMapping;
    readonly Default: BoolTypeMapping;
};


export type BoolTypeMapping = BoolTypeMapping$instance;

export interface ByteArrayTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ByteArrayTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    GenerateNonNullSqlLiteral(value: unknown): string;
}


export const ByteArrayTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>, size: Nullable_1<System_Internal.Int32>): ByteArrayTypeMapping;
    readonly Default: ByteArrayTypeMapping;
};


export type ByteArrayTypeMapping = ByteArrayTypeMapping$instance;

export interface ByteTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ByteTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const ByteTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): ByteTypeMapping;
    readonly Default: ByteTypeMapping;
};


export type ByteTypeMapping = ByteTypeMapping$instance;

export interface CharTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_CharTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    GenerateNonNullSqlLiteral(value: unknown): string;
}


export const CharTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): CharTypeMapping;
    readonly Default: 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 | null;
    readonly ElementTypeMapping: CoreTypeMapping | null;
    readonly JsonValueReaderWriter: JsonValueReaderWriter | null;
    readonly KeyComparer: ValueComparer;
    readonly Parameters: CoreTypeMapping_CoreTypeMappingParameters | RelationalTypeMapping_RelationalTypeMappingParameters;
    readonly ProviderValueComparer: ValueComparer;
    readonly ValueGeneratorFactory: Func_3<IProperty, IEntityType, ValueGenerator> | null;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    GenerateCodeLiteral(value: unknown): Expression;
    WithComposedConverter(converter: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const CoreTypeMapping: (abstract new(parameters: CoreTypeMapping_CoreTypeMappingParameters) => CoreTypeMapping) & {
};


export type CoreTypeMapping = CoreTypeMapping$instance;

export interface CoreTypeMapping_CoreTypeMappingParameters$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_CoreTypeMapping_CoreTypeMappingParameters: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    ClrType: Type;
    get Comparer(): ValueComparer | null;
    set Comparer(value: ValueComparer | null);
    get Converter(): ValueConverter | null;
    set Converter(value: ValueConverter | null);
    get ElementTypeMapping(): CoreTypeMapping | null;
    set ElementTypeMapping(value: CoreTypeMapping | null);
    get JsonValueReaderWriter(): JsonValueReaderWriter | null;
    set JsonValueReaderWriter(value: JsonValueReaderWriter | null);
    get KeyComparer(): ValueComparer | null;
    set KeyComparer(value: ValueComparer | null);
    get ProviderValueComparer(): ValueComparer | null;
    set ProviderValueComparer(value: ValueComparer | null);
    readonly ValueGeneratorFactory: Func_3<IProperty, ITypeBase, ValueGenerator> | null;
    Equals(obj: unknown): boolean;
    Equals(other: CoreTypeMapping_CoreTypeMappingParameters): boolean;
    GetHashCode(): int;
    ToString(): string;
    WithComposedConverter(converter: ValueConverter | null, comparer: ValueComparer | null, keyComparer: ValueComparer | null, elementMapping: CoreTypeMapping | null, jsonValueReaderWriter: JsonValueReaderWriter | null): CoreTypeMapping_CoreTypeMappingParameters;
}


export const CoreTypeMapping_CoreTypeMappingParameters: {
    new(clrType: Type, converter: ValueConverter | null, comparer: ValueComparer | null, keyComparer: ValueComparer | null, providerValueComparer: ValueComparer | null, valueGeneratorFactory: Func_3<IProperty, ITypeBase, ValueGenerator> | null, elementMapping: CoreTypeMapping | null, jsonValueReaderWriter: JsonValueReaderWriter | null): CoreTypeMapping_CoreTypeMappingParameters;
};


export type CoreTypeMapping_CoreTypeMappingParameters = CoreTypeMapping_CoreTypeMappingParameters$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 extends unknown>(query: Expression, async: boolean): Func_2<QueryContext, TResult>;
    CompileQueryExpression<TResult extends unknown>(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 const Database: (abstract new(dependencies: DatabaseDependencies) => Database) & {
};


export interface __Database$views {
    As_IDatabase(): 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;
    _Clone_$(): DatabaseDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: DatabaseDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const DatabaseDependencies: {
    new(queryCompilationContextFactory: IQueryCompilationContextFactory, updateAdapterFactory: IUpdateAdapterFactory, logger: IDiagnosticsLogger_1<DbLoggerCategory_Update>): DatabaseDependencies;
};


export type DatabaseDependencies = DatabaseDependencies$instance;

export interface DatabaseProvider_1$instance<TOptionsExtension extends (object | null) & 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 | null;
    IsConfigured(options: IDbContextOptions): boolean;
}


export const DatabaseProvider_1: {
    new<TOptionsExtension extends (object | null) & IDbContextOptionsExtension>(dependencies: DatabaseProviderDependencies): DatabaseProvider_1<TOptionsExtension>;
};


export interface __DatabaseProvider_1$views<TOptionsExtension extends (object | null) & IDbContextOptionsExtension> {
    As_IDatabaseProvider(): IDatabaseProvider$instance;
}

export type DatabaseProvider_1<TOptionsExtension extends (object | null) & 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 | null): boolean;
    Equals(other: DatabaseProviderDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const DatabaseProviderDependencies: {
    new(): 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: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const DateOnlyTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): DateOnlyTypeMapping;
    readonly Default: 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: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const DateTimeOffsetTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): DateTimeOffsetTypeMapping;
    readonly Default: 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: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const DateTimeTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): DateTimeTypeMapping;
    readonly Default: 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: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const DecimalTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>, precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): DecimalTypeMapping;
    readonly Default: DecimalTypeMapping;
};


export type DecimalTypeMapping = DecimalTypeMapping$instance;

export interface DoubleTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_DoubleTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    GenerateNonNullSqlLiteral(value: unknown): string;
}


export const DoubleTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): DoubleTypeMapping;
    readonly Default: DoubleTypeMapping;
};


export type DoubleTypeMapping = DoubleTypeMapping$instance;

export interface ExecutionResult_1$instance<TResult extends unknown> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ExecutionResult_1: never;

    readonly IsSuccessful: boolean;
    readonly Result: TResult;
}


export const ExecutionResult_1: {
    new<TResult extends unknown>(successful: boolean, result: TResult): ExecutionResult_1<TResult>;
};


export type ExecutionResult_1<TResult extends unknown> = ExecutionResult_1$instance<TResult>;

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_1<Exception>;
    readonly MaxRetryCount: int;
    readonly MaxRetryDelay: TimeSpan;
    readonly Random: Random;
    readonly RetriesOnFailure: boolean;
    Execute<TState extends unknown, TResult extends unknown>(state: TState, operation: Func_3<DbContext, TState, TResult>, verifySucceeded: Func_3<DbContext, TState, ExecutionResult_1<TResult>> | null): TResult;
    ExecuteAsync<TState extends unknown, TResult extends unknown>(state: TState, operation: Func_4<DbContext, TState, CancellationToken, Task_1<TResult>>, verifySucceeded: Func_4<DbContext, TState, CancellationToken, Task_1<ExecutionResult_1<TResult>>> | null, cancellationToken?: CancellationToken): Task_1<TResult>;
    GetNextDelay(lastException: Exception): Nullable_1<TimeSpan>;
    OnFirstExecution(): void;
    OnRetry(): void;
    ShouldRetryOn(exception: Exception): boolean;
    ShouldVerifySuccessOn(exception: Exception): boolean;
}


export const ExecutionStrategy: (abstract new(context: DbContext, maxRetryCount: int, maxRetryDelay: TimeSpan) => ExecutionStrategy) & (abstract new(dependencies: ExecutionStrategyDependencies, maxRetryCount: int, maxRetryDelay: TimeSpan) => ExecutionStrategy) & {
    readonly DefaultMaxRetryCount: int;
    readonly DefaultMaxDelay: TimeSpan;
    get Current(): ExecutionStrategy | null;
    set Current(value: ExecutionStrategy | null);
    CallOnWrappedException<TResult extends unknown>(exception: Exception, exceptionHandler: Func_2<Exception, TResult>): TResult;
};


export interface __ExecutionStrategy$views {
    As_IExecutionStrategy(): 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;
    _Clone_$(): ExecutionStrategyDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: ExecutionStrategyDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const ExecutionStrategyDependencies: {
    new(currentContext: ICurrentDbContext, options: IDbContextOptions, logger: IDiagnosticsLogger_1<DbLoggerCategory_Infrastructure>): ExecutionStrategyDependencies;
};


export type ExecutionStrategyDependencies = ExecutionStrategyDependencies$instance;

export interface FloatTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_FloatTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    GenerateNonNullSqlLiteral(value: unknown): string;
}


export const FloatTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): FloatTypeMapping;
    readonly Default: 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: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const GuidTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): GuidTypeMapping;
    readonly Default: GuidTypeMapping;
};


export type GuidTypeMapping = GuidTypeMapping$instance;

export interface IntTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_IntTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const IntTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): IntTypeMapping;
    readonly Default: 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_1<DbType>) => JsonTypeMapping) & (abstract new(parameters: RelationalTypeMapping_RelationalTypeMappingParameters) => JsonTypeMapping) & {
};


export type JsonTypeMapping = JsonTypeMapping$instance;

export interface JsonTypePlaceholder$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_JsonTypePlaceholder: never;

}


export const JsonTypePlaceholder: {
};


export type JsonTypePlaceholder = JsonTypePlaceholder$instance;

export interface LongTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_LongTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const LongTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): LongTypeMapping;
    readonly Default: LongTypeMapping;
};


export type LongTypeMapping = LongTypeMapping$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 extends unknown, TResult extends unknown>(state: TState, operation: Func_3<DbContext, TState, TResult>, verifySucceeded: Func_3<DbContext, TState, ExecutionResult_1<TResult>> | null): TResult;
    ExecuteAsync<TState extends unknown, TResult extends unknown>(state: TState, operation: Func_4<DbContext, TState, CancellationToken, Task_1<TResult>>, verifySucceeded: Func_4<DbContext, TState, CancellationToken, Task_1<ExecutionResult_1<TResult>>> | null, cancellationToken?: CancellationToken): Task_1<TResult>;
}


export const NonRetryingExecutionStrategy: {
    new(dependencies: ExecutionStrategyDependencies): NonRetryingExecutionStrategy;
    new(context: DbContext): NonRetryingExecutionStrategy;
};


export interface __NonRetryingExecutionStrategy$views {
    As_IExecutionStrategy(): 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;
}


export const ParameterNameGenerator: {
    new(): 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 | null): boolean;
    Equals(other: ParameterNameGeneratorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const ParameterNameGeneratorDependencies: {
    new(): ParameterNameGeneratorDependencies;
};


export type ParameterNameGeneratorDependencies = ParameterNameGeneratorDependencies$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;
}


export const ParameterNameGeneratorFactory: {
    new(dependencies: ParameterNameGeneratorDependencies): ParameterNameGeneratorFactory;
};


export interface __ParameterNameGeneratorFactory$views {
    As_IParameterNameGeneratorFactory(): IParameterNameGeneratorFactory$instance;
}

export type ParameterNameGeneratorFactory = ParameterNameGeneratorFactory$instance & __ParameterNameGeneratorFactory$views;


export interface RawSqlCommand$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RawSqlCommand: never;

    readonly ParameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | null>;
    readonly RelationalCommand: IRelationalCommand;
}


export const RawSqlCommand: {
    new(relationalCommand: IRelationalCommand, parameterValues: IReadOnlyDictionary_2<System_Internal.String, unknown | null>): 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 | null;
    readonly Property: IPropertyBase | null;
    readonly Type: Type;
}


export const ReaderColumn: (abstract new(type: Type, nullable: boolean, name: string | null, property: IPropertyBase | null, getFieldValueExpression: LambdaExpression) => ReaderColumn) & {
    Create(type: Type, nullable: boolean, columnName: string | null, property: IPropertyBase | null, readFunc: LambdaExpression): ReaderColumn;
    GetConstructor(type: Type): ConstructorInfo;
};


export type ReaderColumn = ReaderColumn$instance;

export interface ReaderColumn_1$instance<T extends unknown> extends ReaderColumn {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ReaderColumn_1: never;

    readonly GetFieldValue: Func_3<DbDataReader, int[], T>;
}


export const ReaderColumn_1: {
    new<T extends unknown>(nullable: boolean, name: string | null, property: IPropertyBase | null, getFieldValueExpression: Expression_1<Func_3<DbDataReader, int[], T>>): ReaderColumn_1<T>;
};


export type ReaderColumn_1<T extends unknown> = 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_1<IRelationalParameter>;
    CreateDbCommand(parameterObject: RelationalCommandParameterObject, commandId: Guid, commandMethod: DbCommandMethod): DbCommand;
    CreateRelationalDataReader(): RelationalDataReader;
    ExecuteNonQuery(parameterObject: RelationalCommandParameterObject): int;
    ExecuteNonQueryAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
    ExecuteReader(parameterObject: RelationalCommandParameterObject): RelationalDataReader;
    ExecuteReaderAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task_1<RelationalDataReader>;
    ExecuteScalar(parameterObject: RelationalCommandParameterObject): unknown | null;
    ExecuteScalarAsync(parameterObject: RelationalCommandParameterObject, cancellationToken?: CancellationToken): Task_1<unknown | null>;
    PopulateFrom(commandTemplate: IRelationalCommandTemplate): void;
}


export const RelationalCommand: {
    new(dependencies: RelationalCommandBuilderDependencies, commandText: string, logCommandText: string, parameters: IReadOnlyList_1<IRelationalParameter>): RelationalCommand;
};


export interface __RelationalCommand$views {
    As_IRelationalCommand(): IRelationalCommand$instance;
    As_IRelationalCommandTemplate(): IRelationalCommandTemplate$instance;
}

export type RelationalCommand = RelationalCommand$instance & __RelationalCommand$views;


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_1<IRelationalParameter>;
    readonly TypeMappingSource: IRelationalTypeMappingSource;
    AddParameter(parameter: IRelationalParameter): IRelationalCommandBuilder;
    Append(value: string, sensitive?: boolean): IRelationalCommandBuilder;
    Append(value: FormattableString, sensitive?: boolean): IRelationalCommandBuilder;
    AppendLine(): IRelationalCommandBuilder;
    Build(): IRelationalCommand;
    DecrementIndent(): IRelationalCommandBuilder;
    IncrementIndent(): IRelationalCommandBuilder;
    RemoveParameterAt(index: int): IRelationalCommandBuilder;
    ToString(): string;
}


export const RelationalCommandBuilder: {
    new(dependencies: RelationalCommandBuilderDependencies): RelationalCommandBuilder;
};


export interface __RelationalCommandBuilder$views {
    As_IRelationalCommandBuilder(): IRelationalCommandBuilder$instance;
}

export type RelationalCommandBuilder = RelationalCommandBuilder$instance & __RelationalCommandBuilder$views;


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;
    _Clone_$(): RelationalCommandBuilderDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalCommandBuilderDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalCommandBuilderDependencies: {
    new(typeMappingSource: IRelationalTypeMappingSource, exceptionDetector: IExceptionDetector, loggingOptions: ILoggingOptions): RelationalCommandBuilderDependencies;
};


export type RelationalCommandBuilderDependencies = RelationalCommandBuilderDependencies$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;
}


export const RelationalCommandBuilderFactory: {
    new(dependencies: RelationalCommandBuilderDependencies): RelationalCommandBuilderFactory;
};


export interface __RelationalCommandBuilderFactory$views {
    As_IRelationalCommandBuilderFactory(): IRelationalCommandBuilderFactory$instance;
}

export type RelationalCommandBuilderFactory = RelationalCommandBuilderFactory$instance & __RelationalCommandBuilderFactory$views;


export interface RelationalConnection$instance {
    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;

    get CommandTimeout(): Nullable_1<System_Internal.Int32>;
    set CommandTimeout(value: Nullable_1<System_Internal.Int32> | int);
    readonly ConnectionId: Guid;
    get ConnectionString(): string | null;
    set ConnectionString(value: string | null);
    readonly Context: DbContext;
    readonly CurrentAmbientTransaction: Transaction | null;
    get CurrentTransaction(): IDbContextTransaction | null;
    set CurrentTransaction(value: IDbContextTransaction | null);
    DbConnection: DbConnection;
    readonly Dependencies: RelationalConnectionDependencies;
    get EnlistedTransaction(): Transaction | null;
    set EnlistedTransaction(value: Transaction | null);
    readonly SupportsAmbientTransactions: boolean;
    BeginTransaction(): IDbContextTransaction;
    BeginTransaction(isolationLevel: IsolationLevel): IDbContextTransaction;
    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
    BeginTransactionAsync(isolationLevel: IsolationLevel, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
    Close(): 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_1<DbTransaction>;
    ConnectionEnlistTransaction(transaction: Transaction | null): void;
    CreateDbConnection(): DbConnection;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    DisposeDbConnection(): void;
    DisposeDbConnectionAsync(): ValueTask;
    EnlistTransaction(transaction: Transaction | null): void;
    GetValidatedConnectionString(): string;
    Open(errorsExpected?: boolean): boolean;
    OpenAsync(cancellationToken: CancellationToken, errorsExpected?: boolean): Task_1<System_Internal.Boolean>;
    OpenDbConnection(errorsExpected: boolean): void;
    OpenDbConnectionAsync(errorsExpected: boolean, cancellationToken: CancellationToken): Task;
    RentCommand(): IRelationalCommand;
    ResetState(disposeDbConnection: boolean): void;
    ResetStateAsync(disposeDbConnection: boolean): ValueTask;
    ReturnCommand(command: IRelationalCommand): void;
    RollbackTransaction(): void;
    RollbackTransactionAsync(cancellationToken?: CancellationToken): Task;
    SetDbConnection(value: DbConnection | null, contextOwnsConnection: boolean): void;
    UseTransaction(transaction: DbTransaction | null): IDbContextTransaction | null;
    UseTransaction(transaction: DbTransaction | null, transactionId: Guid): IDbContextTransaction | null;
    UseTransactionAsync(transaction: DbTransaction | null, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | null>;
    UseTransactionAsync(transaction: DbTransaction | null, transactionId: Guid, cancellationToken?: CancellationToken): Task_1<IDbContextTransaction | null>;
}


export const RelationalConnection: (abstract new(dependencies: RelationalConnectionDependencies) => RelationalConnection) & {
};


export interface __RelationalConnection$views {
    As_IResettableService(): Microsoft_EntityFrameworkCore_Infrastructure_Internal.IResettableService$instance;
    As_IDbContextTransactionManager(): IDbContextTransactionManager$instance;
    As_ITransactionEnlistmentManager(): ITransactionEnlistmentManager$instance;
    As_IRelationalConnection(): IRelationalConnection$instance;
    As_IRelationalTransactionManager(): IRelationalTransactionManager$instance;
}

export type RelationalConnection = RelationalConnection$instance & __RelationalConnection$views;


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;
    CurrentContext: ICurrentDbContext;
    ExceptionDetector: IExceptionDetector;
    RelationalCommandBuilderFactory: IRelationalCommandBuilderFactory;
    RelationalTransactionFactory: IRelationalTransactionFactory;
    TransactionLogger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>;
    _Clone_$(): RelationalConnectionDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalConnectionDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalConnectionDependencies: {
    new(contextOptions: IDbContextOptions, transactionLogger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>, connectionLogger: IRelationalConnectionDiagnosticsLogger, connectionStringResolver: INamedConnectionStringResolver, relationalTransactionFactory: IRelationalTransactionFactory, currentContext: ICurrentDbContext, relationalCommandBuilderFactory: IRelationalCommandBuilderFactory, exceptionDetector: IExceptionDetector): RelationalConnectionDependencies;
};


export type RelationalConnectionDependencies = RelationalConnectionDependencies$instance;

export interface RelationalDatabase$instance extends Database$instance, IDatabase$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalDatabase: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabase: never;

    readonly RelationalDependencies: RelationalDatabaseDependencies;
    SaveChanges(entries: IList_1<IUpdateEntry>): int;
    SaveChangesAsync(entries: IList_1<IUpdateEntry>, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
}


export const RelationalDatabase: {
    new(dependencies: DatabaseDependencies, relationalDependencies: RelationalDatabaseDependencies): RelationalDatabase;
};


export interface __RelationalDatabase$views {
    As_IDatabase(): IDatabase$instance;
}

export type RelationalDatabase = RelationalDatabase$instance & __RelationalDatabase$views;


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_1<System_Internal.Boolean>;
    Create(): void;
    CreateAsync(cancellationToken?: CancellationToken): Task;
    CreateTables(): void;
    CreateTablesAsync(cancellationToken?: CancellationToken): Task;
    Delete(): void;
    DeleteAsync(cancellationToken?: CancellationToken): Task;
    EnsureCreated(): boolean;
    EnsureCreatedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
    EnsureDeleted(): boolean;
    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
    Exists(): boolean;
    ExistsAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
    GenerateCreateScript(): string;
    GetCreateTablesCommands(options?: MigrationsSqlGenerationOptions): IReadOnlyList_1<MigrationCommand>;
    HasTables(): boolean;
    HasTablesAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
}


export const RelationalDatabaseCreator: (abstract new(dependencies: RelationalDatabaseCreatorDependencies) => RelationalDatabaseCreator) & {
};


export interface __RelationalDatabaseCreator$views {
    As_IDatabaseCreator(): IDatabaseCreator$instance;
    As_IRelationalDatabaseCreator(): 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;
    CurrentContext: ICurrentDbContext;
    ExceptionDetector: IExceptionDetector;
    readonly ExecutionStrategy: IExecutionStrategy;
    MigrationCommandExecutor: IMigrationCommandExecutor;
    MigrationsSqlGenerator: IMigrationsSqlGenerator;
    ModelDiffer: IMigrationsModelDiffer;
    SqlGenerationHelper: ISqlGenerationHelper;
    _Clone_$(): RelationalDatabaseCreatorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalDatabaseCreatorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalDatabaseCreatorDependencies: {
    new(connection: IRelationalConnection, modelDiffer: IMigrationsModelDiffer, migrationsSqlGenerator: IMigrationsSqlGenerator, migrationCommandExecutor: IMigrationCommandExecutor, sqlGenerationHelper: ISqlGenerationHelper, executionStrategy: IExecutionStrategy, currentContext: ICurrentDbContext, contextOptions: IDbContextOptions, commandLogger: IRelationalCommandDiagnosticsLogger, exceptionDetector: IExceptionDetector): 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;
    _Clone_$(): RelationalDatabaseDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalDatabaseDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalDatabaseDependencies: {
    new(batchPreparer: ICommandBatchPreparer, batchExecutor: IBatchExecutor, connection: IRelationalConnection): 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;
    readonly RelationalConnection: IRelationalConnection;
    Close(): void;
    CloseAsync(): ValueTask;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    Initialize(relationalConnection: IRelationalConnection, command: DbCommand, reader: DbDataReader, commandId: Guid, logger: IRelationalCommandDiagnosticsLogger | null): void;
    Read(): boolean;
    ReadAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
}


export const RelationalDataReader: {
    new(): RelationalDataReader;
};


export type RelationalDataReader = RelationalDataReader$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;
}


export const RelationalExecutionStrategyFactory: {
    new(dependencies: ExecutionStrategyDependencies): RelationalExecutionStrategyFactory;
};


export interface __RelationalExecutionStrategyFactory$views {
    As_IExecutionStrategyFactory(): IExecutionStrategyFactory$instance;
}

export type RelationalExecutionStrategyFactory = RelationalExecutionStrategyFactory$instance & __RelationalExecutionStrategyFactory$views;


export interface RelationalGeometryTypeMapping_2$instance<TGeometry extends unknown, TProvider extends unknown> extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalGeometryTypeMapping_2: never;

    readonly SpatialConverter: ValueConverter_2<TGeometry, TProvider> | null;
    readonly WktReaderType: Type;
    AsText(value: unknown): string;
    CreateParameter(command: DbCommand, name: string, value: unknown | null, nullable?: Nullable_1<System_Internal.Boolean>, direction?: ParameterDirection): DbParameter;
    CustomizeDataReaderExpression(expression: Expression): Expression;
    GenerateCodeLiteral(value: unknown): Expression;
    GetSrid(value: unknown): int;
}


export const RelationalGeometryTypeMapping_2: (abstract new<TGeometry extends unknown, TProvider extends unknown>(converter: ValueConverter_2<TGeometry, TProvider> | null, storeType: string, jsonValueReaderWriter: JsonValueReaderWriter | null) => RelationalGeometryTypeMapping_2<TGeometry, TProvider>) & (abstract new<TGeometry extends unknown, TProvider extends unknown>(parameters: RelationalTypeMapping_RelationalTypeMappingParameters, converter: ValueConverter_2<TGeometry, TProvider> | null) => RelationalGeometryTypeMapping_2<TGeometry, TProvider>) & {
};


export type RelationalGeometryTypeMapping_2<TGeometry extends unknown, TProvider extends unknown> = 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;
    readonly SingleLineCommentToken: string;
    readonly StartTransactionStatement: string;
    readonly StatementTerminator: string;
    DelimitIdentifier(identifier: string): string;
    DelimitIdentifier(builder: StringBuilder, identifier: string): void;
    DelimitIdentifier(name: string, schema: string | null): string;
    DelimitIdentifier(builder: StringBuilder, name: string, schema: string | null): void;
    DelimitJsonPathElement(pathElement: string): string;
    EscapeIdentifier(identifier: string): string;
    EscapeIdentifier(builder: StringBuilder, identifier: string): void;
    EscapeJsonPathElement(identifier: string): string;
    GenerateComment(text: string): string;
    GenerateCreateSavepointStatement(name: string): string;
    GenerateParameterName(name: string): string;
    GenerateParameterName(builder: StringBuilder, name: string): void;
    GenerateParameterNamePlaceholder(name: string): string;
    GenerateParameterNamePlaceholder(builder: StringBuilder, name: string): void;
    GenerateReleaseSavepointStatement(name: string): string;
    GenerateRollbackToSavepointStatement(name: string): string;
}


export const RelationalSqlGenerationHelper: {
    new(dependencies: RelationalSqlGenerationHelperDependencies): RelationalSqlGenerationHelper;
};


export interface __RelationalSqlGenerationHelper$views {
    As_ISqlGenerationHelper(): ISqlGenerationHelper$instance;
}

export type RelationalSqlGenerationHelper = RelationalSqlGenerationHelper$instance & __RelationalSqlGenerationHelper$views;


export interface RelationalSqlGenerationHelperDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalSqlGenerationHelperDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    _Clone_$(): RelationalSqlGenerationHelperDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalSqlGenerationHelperDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalSqlGenerationHelperDependencies: {
    new(): RelationalSqlGenerationHelperDependencies;
};


export type RelationalSqlGenerationHelperDependencies = RelationalSqlGenerationHelperDependencies$instance;

export interface RelationalTransaction$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IInfrastructure_1$instance<DbTransaction>, IDbContextTransaction$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;
    readonly TransactionId: Guid;
    ClearTransaction(): void;
    ClearTransactionAsync(cancellationToken?: CancellationToken): Task;
    Commit(): void;
    CommitAsync(cancellationToken?: CancellationToken): Task;
    CreateSavepoint(name: string): void;
    CreateSavepointAsync(name: string, cancellationToken?: CancellationToken): Task;
    Dispose(): void;
    DisposeAsync(): ValueTask;
    ReleaseSavepoint(name: string): void;
    ReleaseSavepointAsync(name: string, cancellationToken?: CancellationToken): Task;
    Rollback(): void;
    RollbackAsync(cancellationToken?: CancellationToken): Task;
    RollbackToSavepoint(name: string): void;
    RollbackToSavepointAsync(name: string, cancellationToken?: CancellationToken): Task;
}


export const RelationalTransaction: {
    new(connection: IRelationalConnection, transaction: DbTransaction, transactionId: Guid, logger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Transaction>, transactionOwned: boolean, sqlGenerationHelper: ISqlGenerationHelper): RelationalTransaction;
};


export interface __RelationalTransaction$views {
    As_IInfrastructure_1(): Microsoft_EntityFrameworkCore_Infrastructure_Internal.IInfrastructure_1$instance<DbTransaction>;
    As_IDbContextTransaction(): IDbContextTransaction$instance;
}

export type RelationalTransaction = RelationalTransaction$instance & __RelationalTransaction$views;


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;
}


export const RelationalTransactionFactory: {
    new(dependencies: RelationalTransactionFactoryDependencies): RelationalTransactionFactory;
};


export interface __RelationalTransactionFactory$views {
    As_IRelationalTransactionFactory(): 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 | null): boolean;
    Equals(other: RelationalTransactionFactoryDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalTransactionFactoryDependencies: {
    new(sqlGenerationHelper: ISqlGenerationHelper): RelationalTransactionFactoryDependencies;
};


export type RelationalTransactionFactoryDependencies = RelationalTransactionFactoryDependencies$instance;

export interface RelationalTypeMapping$instance extends CoreTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTypeMapping: never;

    readonly DbType: Nullable_1<DbType>;
    readonly IsFixedLength: boolean;
    readonly IsUnicode: boolean;
    readonly Parameters: CoreTypeMapping_CoreTypeMappingParameters | RelationalTypeMapping_RelationalTypeMappingParameters;
    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: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    ConfigureParameter(parameter: DbParameter): void;
    CreateParameter(command: DbCommand, name: string, value: unknown | null, nullable?: Nullable_1<System_Internal.Boolean>, direction?: ParameterDirection): DbParameter;
    CustomizeDataReaderExpression(expression: Expression): Expression;
    GenerateNonNullSqlLiteral(value: unknown): string;
    GenerateProviderValueSqlLiteral(value: unknown | null): string;
    GenerateSqlLiteral(value: unknown | null): string;
    GetDataReaderMethod(): MethodInfo;
    ProcessStoreType(parameters: RelationalTypeMapping_RelationalTypeMappingParameters, storeType: string, storeTypeNameBase: string): string;
    WithComposedConverter(converter: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    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: RelationalTypeMapping_RelationalTypeMappingParameters) => 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 | null) => RelationalTypeMapping) & {
    readonly NullMapping: RelationalTypeMapping;
    GetDataReaderMethod(type: Type): MethodInfo;
};


export type RelationalTypeMapping = RelationalTypeMapping$instance;

export interface RelationalTypeMapping_RelationalTypeMappingParameters$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTypeMapping_RelationalTypeMappingParameters: never;

    readonly CoreParameters: CoreTypeMapping_CoreTypeMappingParameters;
    readonly DbType: Nullable_1<DbType>;
    readonly FixedLength: boolean;
    readonly Precision: Nullable_1<System_Internal.Int32>;
    readonly Scale: Nullable_1<System_Internal.Int32>;
    readonly Size: Nullable_1<System_Internal.Int32>;
    readonly StoreType: string;
    readonly StoreTypePostfix: StoreTypePostfix;
    readonly Unicode: boolean;
    WithComposedConverter(converter: ValueConverter | null, comparer: ValueComparer | null, keyComparer: ValueComparer | null, elementMapping: CoreTypeMapping | null, jsonValueReaderWriter: JsonValueReaderWriter | null): RelationalTypeMapping_RelationalTypeMappingParameters;
    WithCoreParameters(coreParameters: CoreTypeMapping_CoreTypeMappingParameters): RelationalTypeMapping_RelationalTypeMappingParameters;
    WithPrecision(precision: Nullable_1<System_Internal.Int32>): RelationalTypeMapping_RelationalTypeMappingParameters;
    WithPrecisionAndScale(precision: Nullable_1<System_Internal.Int32>, scale: Nullable_1<System_Internal.Int32>): RelationalTypeMapping_RelationalTypeMappingParameters;
    WithScale(scale: Nullable_1<System_Internal.Int32>): RelationalTypeMapping_RelationalTypeMappingParameters;
    WithStoreTypeAndSize(storeType: string, size: Nullable_1<System_Internal.Int32>, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping_RelationalTypeMappingParameters;
    WithTypeMappingInfo(mappingInfo: RelationalTypeMappingInfo, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping_RelationalTypeMappingParameters;
}


export const RelationalTypeMapping_RelationalTypeMappingParameters: {
    new(coreParameters: CoreTypeMapping_CoreTypeMappingParameters, storeType: string, storeTypePostfix: StoreTypePostfix, 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>): RelationalTypeMapping_RelationalTypeMappingParameters;
};


export type RelationalTypeMapping_RelationalTypeMappingParameters = RelationalTypeMapping_RelationalTypeMappingParameters$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 | null, elementMapping: CoreTypeMapping | null): RelationalTypeMapping | null;
    FindMapping(mappingInfo: RelationalTypeMappingInfo): RelationalTypeMapping | null;
    FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping;
    FindMapping(property: IProperty): CoreTypeMapping | null;
    FindMapping(elementType: IElementType): CoreTypeMapping | null;
    FindMapping(type: Type): RelationalTypeMapping | null;
    FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping | null): RelationalTypeMapping | null;
    FindMapping(member: MemberInfo): RelationalTypeMapping | null;
    FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): RelationalTypeMapping | null;
    FindMapping(storeTypeName: string): RelationalTypeMapping | null;
    FindMapping(type: Type, storeTypeName: string | null, 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 | null;
    FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | null;
    ParseStoreTypeName(storeTypeName: string | null, 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 | null;
}


export const RelationalTypeMappingSource: (abstract new(dependencies: TypeMappingSourceDependencies, relationalDependencies: RelationalTypeMappingSourceDependencies) => RelationalTypeMappingSource) & {
};


export interface __RelationalTypeMappingSource$views {
    As_ITypeMappingSource(): ITypeMappingSource$instance;
    As_IRelationalTypeMappingSource(): IRelationalTypeMappingSource$instance;
}

export type RelationalTypeMappingSource = RelationalTypeMappingSource$instance & __RelationalTypeMappingSource$views;


export interface RelationalTypeMappingSourceDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_RelationalTypeMappingSourceDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Plugins: IEnumerable_1<IRelationalTypeMappingSourcePlugin>;
    _Clone_$(): RelationalTypeMappingSourceDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalTypeMappingSourceDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const 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;

}


export const RetryLimitExceededException: {
    new(): RetryLimitExceededException;
    new(message: string): RetryLimitExceededException;
    new(message: string, innerException: Exception): RetryLimitExceededException;
    new(info: SerializationInfo, context: StreamingContext): RetryLimitExceededException;
};


export type RetryLimitExceededException = RetryLimitExceededException$instance;

export interface SByteTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_SByteTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const SByteTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): SByteTypeMapping;
    readonly Default: SByteTypeMapping;
};


export type SByteTypeMapping = SByteTypeMapping$instance;

export interface ShortTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ShortTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const ShortTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): ShortTypeMapping;
    readonly Default: ShortTypeMapping;
};


export type ShortTypeMapping = ShortTypeMapping$instance;

export interface StringTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_StringTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    EscapeSqlLiteral(literal: string): string;
    GenerateNonNullSqlLiteral(value: unknown): string;
}


export const StringTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>, unicode: boolean, size: Nullable_1<System_Internal.Int32>): StringTypeMapping;
    readonly Default: StringTypeMapping;
};


export type StringTypeMapping = StringTypeMapping$instance;

export interface TimeOnlyTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TimeOnlyTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
    GenerateNonNullSqlLiteral(value: unknown): string;
}


export const TimeOnlyTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): TimeOnlyTypeMapping;
    readonly Default: 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: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const TimeSpanTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): TimeSpanTypeMapping;
    readonly Default: 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 | null, elementMapping: CoreTypeMapping | null): CoreTypeMapping | null;
    FindMapping(property: IProperty): CoreTypeMapping | null;
    FindMapping(elementType: IElementType): CoreTypeMapping | null;
    FindMapping(type: Type): CoreTypeMapping | null;
    FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping | null): CoreTypeMapping | null;
    FindMapping(member: MemberInfo): CoreTypeMapping | null;
    FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | null;
    FindMapping(mappingInfo: TypeMappingInfo): CoreTypeMapping | null;
}


export const TypeMappingSource: (abstract new(dependencies: TypeMappingSourceDependencies) => TypeMappingSource) & {
};


export interface __TypeMappingSource$views {
    As_ITypeMappingSource(): ITypeMappingSource$instance;
}

export type TypeMappingSource = TypeMappingSource$instance & __TypeMappingSource$views;


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 | null;
    FindMapping(property: IProperty): CoreTypeMapping | null;
    FindMapping(elementType: IElementType): CoreTypeMapping | null;
    FindMapping(type: Type): CoreTypeMapping | null;
    FindMapping(type: Type, model: IModel, elementMapping?: CoreTypeMapping | null): CoreTypeMapping | null;
    FindMapping(member: MemberInfo): CoreTypeMapping | null;
    FindMapping(member: MemberInfo, model: IModel, useAttributes: boolean): CoreTypeMapping | null;
    TryFindJsonCollectionMapping(mappingInfo: TypeMappingInfo, modelClrType: Type, providerClrType: Type | null, elementMapping: CoreTypeMapping | null, elementComparer: ValueComparer | null, collectionReaderWriter: JsonValueReaderWriter | null): boolean;
    ValidateMapping(mapping: CoreTypeMapping | null, property: IProperty | null): void;
}


export const TypeMappingSourceBase: (abstract new(dependencies: TypeMappingSourceDependencies) => TypeMappingSourceBase) & {
};


export interface __TypeMappingSourceBase$views {
    As_ITypeMappingSource(): ITypeMappingSource$instance;
}

export type TypeMappingSourceBase = TypeMappingSourceBase$instance & __TypeMappingSourceBase$views;


export interface TypeMappingSourceDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TypeMappingSourceDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    readonly JsonValueReaderWriterSource: IJsonValueReaderWriterSource;
    Plugins: IEnumerable_1<ITypeMappingSourcePlugin>;
    ValueConverterSelector: IValueConverterSelector;
    _Clone_$(): TypeMappingSourceDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: TypeMappingSourceDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const TypeMappingSourceDependencies: {
    new(valueConverterSelector: IValueConverterSelector, jsonValueReaderWriterSource: IJsonValueReaderWriterSource, plugins: IEnumerable_1<ITypeMappingSourcePlugin>): TypeMappingSourceDependencies;
};


export type TypeMappingSourceDependencies = TypeMappingSourceDependencies$instance;

export interface TypeMaterializationInfo$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_TypeMaterializationInfo: never;

    readonly IsNullable: Nullable_1<System_Internal.Boolean>;
    readonly Mapping: RelationalTypeMapping;
    readonly ModelClrType: Type;
    readonly Property: IProperty | null;
    readonly ProviderClrType: Type;
    Equals(other: TypeMaterializationInfo): boolean;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
}


export const TypeMaterializationInfo: {
    new(modelClrType: Type, property: IProperty | null, 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: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const UIntTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): UIntTypeMapping;
    readonly Default: UIntTypeMapping;
};


export type UIntTypeMapping = UIntTypeMapping$instance;

export interface ULongTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_ULongTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const ULongTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): ULongTypeMapping;
    readonly Default: ULongTypeMapping;
};


export type ULongTypeMapping = ULongTypeMapping$instance;

export interface UShortTypeMapping$instance extends RelationalTypeMapping {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Storage_UShortTypeMapping: never;

    Clone(parameters: RelationalTypeMapping_RelationalTypeMappingParameters): RelationalTypeMapping;
    Clone(parameters: CoreTypeMapping_CoreTypeMappingParameters): CoreTypeMapping;
    Clone(mappingInfo?: Nullable_1<RelationalTypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null, storeTypePostfix?: Nullable_1<StoreTypePostfix>): RelationalTypeMapping;
    Clone(mappingInfo?: Nullable_1<TypeMappingInfo>, clrType?: Type | null, converter?: ValueConverter | null, comparer?: ValueComparer | null, keyComparer?: ValueComparer | null, providerValueComparer?: ValueComparer | null, elementMapping?: CoreTypeMapping | null, jsonValueReaderWriter?: JsonValueReaderWriter | null): CoreTypeMapping;
}


export const UShortTypeMapping: {
    new(storeType: string, dbType: Nullable_1<DbType>): UShortTypeMapping;
    readonly Default: UShortTypeMapping;
};


export type UShortTypeMapping = UShortTypeMapping$instance;

export abstract class DbContextTransactionExtensions$instance {
    static GetDbTransaction(dbContextTransaction: IDbContextTransaction): DbTransaction;
}


export type DbContextTransactionExtensions = DbContextTransactionExtensions$instance;

export abstract class RelationalCommandBuilderExtensions$instance {
    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;
    static AppendLine(commandBuilder: IRelationalCommandBuilder, value: string): IRelationalCommandBuilder;
    static AppendLines(commandBuilder: IRelationalCommandBuilder, value: string, skipFinalNewline?: boolean): IRelationalCommandBuilder;
    static Indent(commandBuilder: IRelationalCommandBuilder): IDisposable;
}


export type RelationalCommandBuilderExtensions = RelationalCommandBuilderExtensions$instance;

export abstract class RelationalExecutionStrategyExtensions$instance {
    static ExecuteInTransaction<TResult extends unknown>(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 extends unknown>(strategy: IExecutionStrategy, state: TState, operation: Action_1<TState>, verifySucceeded: Func_2<TState, System_Internal.Boolean>, isolationLevel: IsolationLevel): void;
    static ExecuteInTransaction<TState extends unknown, TResult extends unknown>(strategy: IExecutionStrategy, state: TState, operation: Func_2<TState, TResult>, verifySucceeded: Func_2<TState, System_Internal.Boolean>, isolationLevel: IsolationLevel): TResult;
    static ExecuteInTransactionAsync<TResult extends unknown>(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 extends unknown>(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 extends unknown, TResult extends unknown>(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>;
}


export type RelationalExecutionStrategyExtensions = RelationalExecutionStrategyExtensions$instance;

export abstract class RelationalTypeMappingSourceExtensions$instance {
    static GetMapping(typeMappingSource: IRelationalTypeMappingSource, property: IProperty): RelationalTypeMapping;
    static GetMapping(typeMappingSource: IRelationalTypeMappingSource, typeName: string): RelationalTypeMapping;
    static GetMapping(typeMappingSource: IRelationalTypeMappingSource, clrType: Type, model: IModel): RelationalTypeMapping;
    static GetMapping(typeMappingSource: IRelationalTypeMappingSource, clrType: Type): RelationalTypeMapping;
    static GetMappingForValue(typeMappingSource: IRelationalTypeMappingSource, value: unknown | null, model: IModel): RelationalTypeMapping;
    static GetMappingForValue(typeMappingSource: IRelationalTypeMappingSource, value: unknown | null): RelationalTypeMapping;
}


export type RelationalTypeMappingSourceExtensions = RelationalTypeMappingSourceExtensions$instance;