// Generated by tsbindgen - Architecture
// Namespace: Microsoft.EntityFrameworkCore.Internal
// 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 { IChangeDetector, IEntityGraphAttacher, InternalEntityEntry, IStateManager } from "../../Microsoft.EntityFrameworkCore.ChangeTracking.Internal/internal/index.js";
import type { CascadeTiming, DetectChangesEventArgs, DetectedChangesEventArgs, DetectedEntityChangesEventArgs, DetectEntityChangesEventArgs, EntityEntry_1, EntityStateChangedEventArgs, EntityStateChangingEventArgs, EntityTrackedEventArgs, EntityTrackingEventArgs, LoadOptions, LocalView_1 } from "../../Microsoft.EntityFrameworkCore.ChangeTracking/internal/index.js";
import type { IDiagnosticsLogger_1 } from "../../Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
import * as Microsoft_EntityFrameworkCore_Infrastructure_Internal from "../../Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
import type { ICurrentDbContext, IDbContextOptions, IDbSetFinder, IInfrastructure_1, IResettableService } from "../../Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
import type { TypeBase } from "../../Microsoft.EntityFrameworkCore.Metadata.Internal/internal/index.js";
import type { IComplexProperty, IEntityType, IModel, INavigation, IProperty, IReadOnlyProperty, IReadOnlyPropertyBase, IReadOnlyTypeBase, ISkipNavigation, ITypeBase } from "../../Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
import type { RelationalCommandResolver } from "../../Microsoft.EntityFrameworkCore.Query.Internal/internal/index.js";
import type { IAsyncQueryProvider, RelationalQueryContext } from "../../Microsoft.EntityFrameworkCore.Query/internal/index.js";
import type { ValueConverter } from "../../Microsoft.EntityFrameworkCore.Storage.ValueConversion/internal/index.js";
import type { IExceptionDetector, IRelationalCommand, ValueBuffer } from "../../Microsoft.EntityFrameworkCore.Storage/internal/index.js";
import * as Microsoft_EntityFrameworkCore_Internal from "../../Microsoft.EntityFrameworkCore/internal/index.js";
import type { AutoTransactionBehavior, DbContext, DbContextOptions, DbContextOptions_1, DbLoggerCategory_Infrastructure, DbLoggerCategory_Update, DbSet_1, IDbContextFactory_1, ModelConfigurationBuilder, QueryTrackingBehavior, SaveChangesFailedEventArgs, SavedChangesEventArgs, SavingChangesEventArgs } from "../../Microsoft.EntityFrameworkCore/internal/index.js";
import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
import type { IAsyncEnumerable_1, IAsyncEnumerator_1, IComparer_1, IEnumerable_1, IEqualityComparer_1, IReadOnlyDictionary_2, IReadOnlyList_1, ISet_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
import * as System_Collections_Internal from "@tsonic/dotnet/System.Collections/internal/index.js";
import type { IEnumerable, IEqualityComparer } from "@tsonic/dotnet/System.Collections/internal/index.js";
import * as System_ComponentModel_Internal from "@tsonic/dotnet/System.ComponentModel/internal/index.js";
import type { IListSource } from "@tsonic/dotnet/System.ComponentModel/internal/index.js";
import type { Expression, LambdaExpression, ParameterExpression, UnaryExpression } from "@tsonic/dotnet/System.Linq.Expressions/internal/index.js";
import * as System_Linq_Internal from "@tsonic/dotnet/System.Linq/internal/index.js";
import type { IQueryable, IQueryable_1 } from "@tsonic/dotnet/System.Linq/internal/index.js";
import type { FieldInfo, MemberInfo, MethodInfo, PropertyInfo } from "@tsonic/dotnet/System.Reflection/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 * as System_Internal from "@tsonic/dotnet/System/internal/index.js";
import type { Boolean as ClrBoolean, EventHandler_1, Func_3, IAsyncDisposable, IDisposable, IEquatable_1, Int32, IServiceProvider, Nullable_1, Object as ClrObject, String as ClrString, Type, ValueTuple_2, ValueType, Void } from "@tsonic/dotnet/System/internal/index.js";

export interface ICollectionLoader$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_ICollectionLoader: never;

    Load(entry: InternalEntityEntry, options: LoadOptions): void;
    LoadAsync(entry: InternalEntityEntry, options: LoadOptions, cancellationToken?: CancellationToken): Task;
    Query(entry: InternalEntityEntry): IQueryable;
}


export type ICollectionLoader = ICollectionLoader$instance;

export interface ICollectionLoader_1$instance<TEntity extends (object | null)> extends ICollectionLoader {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_ICollectionLoader_1: never;

    Load(entry: InternalEntityEntry, options: LoadOptions): void;
    LoadAsync(entry: InternalEntityEntry, options: LoadOptions, cancellationToken?: CancellationToken): Task;
    Query(entry: InternalEntityEntry): IQueryable;
    Query(entry: InternalEntityEntry): IQueryable_1<TEntity>;
}


export interface ICollectionLoader_1$instance<TEntity extends (object | null)> extends ICollectionLoader$instance {}

export type ICollectionLoader_1<TEntity extends (object | null)> = ICollectionLoader_1$instance<TEntity>;

export interface IDbContextDependencies$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextDependencies: never;

    readonly SetSource: IDbSetSource;
    readonly EntityFinderFactory: IEntityFinderFactory;
    readonly QueryProvider: IAsyncQueryProvider;
    readonly StateManager: IStateManager;
    readonly ChangeDetector: IChangeDetector;
    readonly EntityGraphAttacher: IEntityGraphAttacher;
    readonly ExceptionDetector: IExceptionDetector;
    readonly UpdateLogger: IDiagnosticsLogger_1<DbLoggerCategory_Update>;
    readonly InfrastructureLogger: IDiagnosticsLogger_1<DbLoggerCategory_Infrastructure>;
}


export type IDbContextDependencies = IDbContextDependencies$instance;

export interface IDbContextFactorySource_1$instance<TContext extends unknown & DbContext> {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextFactorySource_1: never;

    readonly Factory: Func_3<IServiceProvider, DbContextOptions_1<TContext>, TContext>;
}


export type IDbContextFactorySource_1<TContext extends unknown & DbContext> = IDbContextFactorySource_1$instance<TContext>;

export interface IDbContextPool$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextPool: never;

    Rent(): IDbContextPoolable;
    Return(context: IDbContextPoolable): void;
    ReturnAsync(context: IDbContextPoolable, cancellationToken?: CancellationToken): ValueTask;
}


export type IDbContextPool = IDbContextPool$instance;

export interface IDbContextPool_1$instance<TContext extends unknown & DbContext> extends IDbContextPool {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextPool_1: never;

    Rent(): IDbContextPoolable;
    Return(context: IDbContextPoolable): void;
    ReturnAsync(context: IDbContextPoolable, cancellationToken?: CancellationToken): ValueTask;
}


export interface IDbContextPool_1$instance<TContext extends unknown & DbContext> extends IDbContextPool$instance {}

export type IDbContextPool_1<TContext extends unknown & DbContext> = IDbContextPool_1$instance<TContext>;

export interface IDbContextPoolable$instance extends IResettableService, IDisposable, IAsyncDisposable {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextPoolable: never;

    ClearLease(): void;
    ResetStateAsync(cancellationToken?: CancellationToken): Task;
    SetLease(lease: DbContextLease): void;
    SetLeaseAsync(lease: DbContextLease, cancellationToken: CancellationToken): Task;
    ResetState(): void;
}


export interface IDbContextPoolable$instance extends Microsoft_EntityFrameworkCore_Infrastructure_Internal.IResettableService$instance, System_Internal.IAsyncDisposable, System_Internal.IDisposable {}

export type IDbContextPoolable = IDbContextPoolable$instance;

export interface IDbContextServices$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextServices: never;

    readonly CurrentContext: ICurrentDbContext;
    readonly Model: IModel;
    readonly DesignTimeModel: IModel;
    readonly ContextOptions: DbContextOptions;
    readonly InternalServiceProvider: IServiceProvider;
    Initialize(scopedProvider: IServiceProvider, contextOptions: DbContextOptions, context: DbContext): IDbContextServices;
}


export type IDbContextServices = IDbContextServices$instance;

export interface IDbSetCache$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbSetCache: never;

    GetOrAddSet(source: IDbSetSource, entityTypeName: string, type: Type): unknown;
    GetOrAddSet(source: IDbSetSource, type: Type): unknown;
    GetSets(): IEnumerable_1<unknown>;
}


export type IDbSetCache = IDbSetCache$instance;

export interface IDbSetInitializer$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbSetInitializer: never;

    InitializeSets(context: DbContext): void;
}


export type IDbSetInitializer = IDbSetInitializer$instance;

export interface IDbSetSource$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbSetSource: never;

    Create(context: DbContext, name: string, type: Type): unknown;
    Create(context: DbContext, type: Type): unknown;
}


export type IDbSetSource = IDbSetSource$instance;

export interface IEntityFinder$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IEntityFinder: never;

    Find(keyValues: (unknown | null)[] | null): unknown | null;
    FindAsync(keyValues: (unknown | null)[] | null, cancellationToken?: CancellationToken): ValueTask_1<unknown>;
    FindEntry<TProperty extends unknown>(property: IProperty, propertyValue: TProperty): InternalEntityEntry | null;
    FindEntry(properties: IEnumerable_1<IProperty>, propertyValues: IEnumerable_1<unknown | null>): InternalEntityEntry | null;
    FindEntry(keyValues: IEnumerable_1<unknown | null>): InternalEntityEntry | null;
    FindEntry<TKey extends unknown>(keyValue: TKey): InternalEntityEntry | null;
    GetDatabaseValues(entry: InternalEntityEntry): unknown[] | null;
    GetDatabaseValuesAsync(entry: InternalEntityEntry, cancellationToken?: CancellationToken): Task_1<unknown[] | null>;
    GetEntries<TProperty extends unknown>(property: IProperty, propertyValue: TProperty): IEnumerable_1<InternalEntityEntry>;
    GetEntries(properties: IEnumerable_1<IProperty>, propertyValues: IEnumerable_1<unknown | null>): IEnumerable_1<InternalEntityEntry>;
    Load(navigation: INavigation, entry: InternalEntityEntry, options: LoadOptions): void;
    LoadAsync(navigation: INavigation, entry: InternalEntityEntry, options: LoadOptions, cancellationToken?: CancellationToken): Task;
    Query(navigation: INavigation, entry: InternalEntityEntry): IQueryable;
}


export type IEntityFinder = IEntityFinder$instance;

export interface IEntityFinder_1$instance<TEntity extends (object | null)> extends IEntityFinder {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IEntityFinder_1: never;

    Find(keyValues: (unknown | null)[] | null): unknown | null;
    Find(keyValues: (unknown | null)[] | null): TEntity | null;
    FindAsync(keyValues: (unknown | null)[] | null, cancellationToken?: CancellationToken): ValueTask_1<TEntity>;
    FindAsync(keyValues: (unknown | null)[] | null, cancellationToken?: CancellationToken): ValueTask_1<unknown>;
    FindEntry<TProperty extends unknown>(property: IProperty, propertyValue: TProperty): InternalEntityEntry | null;
    FindEntry(properties: IEnumerable_1<IProperty>, propertyValues: IEnumerable_1<unknown | null>): InternalEntityEntry | null;
    FindEntry(keyValues: IEnumerable_1<unknown | null>): InternalEntityEntry | null;
    FindEntry<TKey extends unknown>(keyValue: TKey): InternalEntityEntry | null;
    FindEntry<TKey>(keyValue: TKey): InternalEntityEntry | null;
    FindEntry<TProperty>(property: IProperty, propertyValue: TProperty): InternalEntityEntry | null;
    GetDatabaseValues(entry: InternalEntityEntry): unknown[] | null;
    GetDatabaseValuesAsync(entry: InternalEntityEntry, cancellationToken?: CancellationToken): Task_1<unknown[] | null>;
    GetEntries<TProperty extends unknown>(property: IProperty, propertyValue: TProperty): IEnumerable_1<InternalEntityEntry>;
    GetEntries(properties: IEnumerable_1<IProperty>, propertyValues: IEnumerable_1<unknown | null>): IEnumerable_1<InternalEntityEntry>;
    GetEntries<TProperty>(property: IProperty, propertyValue: TProperty): IEnumerable_1<InternalEntityEntry>;
    Load(navigation: INavigation, entry: InternalEntityEntry, options: LoadOptions): void;
    LoadAsync(navigation: INavigation, entry: InternalEntityEntry, options: LoadOptions, cancellationToken?: CancellationToken): Task;
    Query(navigation: INavigation, entry: InternalEntityEntry): IQueryable;
    Query(navigation: INavigation, entry: InternalEntityEntry): IQueryable_1<TEntity>;
}


export type IEntityFinder_1<TEntity extends (object | null)> = IEntityFinder_1$instance<TEntity>;

export interface IEntityFinderFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IEntityFinderFactory: never;

    Create(type: IEntityType): IEntityFinder;
}


export type IEntityFinderFactory = IEntityFinderFactory$instance;

export interface IEntityFinderSource$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IEntityFinderSource: never;

    Create(stateManager: IStateManager, setSource: IDbSetSource, setCache: IDbSetCache, type: IEntityType): IEntityFinder;
}


export type IEntityFinderSource = IEntityFinderSource$instance;

export interface IInjectableService$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IInjectableService: never;

    Attaching(context: DbContext, entityType: IEntityType, entity: unknown): void;
    Detaching(context: DbContext, entity: unknown): boolean;
    Injected(context: DbContext, entity: unknown, queryTrackingBehavior: Nullable_1<QueryTrackingBehavior>, structuralType: ITypeBase): void;
}


export type IInjectableService = IInjectableService$instance;

export interface IPatchServiceInjectionSite$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IPatchServiceInjectionSite: never;

    InjectServices(serviceProvider: IServiceProvider): void;
}


export type IPatchServiceInjectionSite = IPatchServiceInjectionSite$instance;

export interface IRegisteredServices$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IRegisteredServices: never;

    readonly Services: ISet_1<Type>;
}


export type IRegisteredServices = IRegisteredServices$instance;

export interface IScopedDbContextLease_1$instance<TContext extends unknown & DbContext> {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IScopedDbContextLease_1: never;

    readonly Context: TContext;
}


export type IScopedDbContextLease_1<TContext extends unknown & DbContext> = IScopedDbContextLease_1$instance<TContext>;

export interface ISingletonOptionsInitializer$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_ISingletonOptionsInitializer: never;

    EnsureInitialized(serviceProvider: IServiceProvider, options: IDbContextOptions): void;
}


export type ISingletonOptionsInitializer = ISingletonOptionsInitializer$instance;

export interface DbContextLease$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbContextLease: never;

    Context: IDbContextPoolable;
    readonly IsActive: boolean;
    readonly IsStandalone: boolean;
    ContextDisposed(): void;
    ContextDisposedAsync(): ValueTask;
    Release(): void;
    ReleaseAsync(): ValueTask;
}


export const DbContextLease: {
    new(contextPool: IDbContextPool, standalone: boolean): DbContextLease;
    readonly InactiveLease: DbContextLease;
};


export type DbContextLease = DbContextLease$instance;

export interface DbContextDependencies$instance extends IDbContextDependencies$instance, System_Internal.IEquatable_1<DbContextDependencies> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbContextDependencies: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextDependencies: never;
    readonly __tsonic_iface_System_IEquatable_1: never;

    readonly ChangeDetector: IChangeDetector;
    readonly EntityFinderFactory: IEntityFinderFactory;
    readonly EntityGraphAttacher: IEntityGraphAttacher;
    readonly ExceptionDetector: IExceptionDetector;
    readonly InfrastructureLogger: IDiagnosticsLogger_1<DbLoggerCategory_Infrastructure>;
    readonly QueryProvider: IAsyncQueryProvider;
    readonly SetSource: IDbSetSource;
    readonly StateManager: IStateManager;
    readonly UpdateLogger: IDiagnosticsLogger_1<DbLoggerCategory_Update>;
    _Clone_$(): DbContextDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: DbContextDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const DbContextDependencies: {
    new(currentContext: ICurrentDbContext, changeDetector: IChangeDetector, setSource: IDbSetSource, entityFinderSource: IEntityFinderSource, entityGraphAttacher: IEntityGraphAttacher, queryProvider: IAsyncQueryProvider, stateManager: IStateManager, exceptionDetector: IExceptionDetector, updateLogger: IDiagnosticsLogger_1<DbLoggerCategory_Update>, infrastructureLogger: IDiagnosticsLogger_1<DbLoggerCategory_Infrastructure>): DbContextDependencies;
};


export interface __DbContextDependencies$views {
    As_IDbContextDependencies(): IDbContextDependencies$instance;
}

export type DbContextDependencies = DbContextDependencies$instance & __DbContextDependencies$views;


export interface DbContextFactory_1$instance<TContext extends unknown & DbContext> extends Microsoft_EntityFrameworkCore_Internal.IDbContextFactory_1$instance<TContext> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbContextFactory_1: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_IDbContextFactory_1: never;

    CreateDbContext(): TContext;
    CreateDbContextAsync(cancellationToken?: CancellationToken): Task_1<TContext>;
}


export const DbContextFactory_1: {
    new<TContext extends unknown & DbContext>(serviceProvider: IServiceProvider, options: DbContextOptions_1<TContext>, factorySource: IDbContextFactorySource_1<TContext>): DbContextFactory_1<TContext>;
};


export interface __DbContextFactory_1$views<TContext extends unknown & DbContext> {
    As_IDbContextFactory_1(): Microsoft_EntityFrameworkCore_Internal.IDbContextFactory_1$instance<TContext>;
}

export type DbContextFactory_1<TContext extends unknown & DbContext> = DbContextFactory_1$instance<TContext> & __DbContextFactory_1$views<TContext>;


export interface DbContextFactorySource_1$instance<TContext extends unknown & DbContext> extends IDbContextFactorySource_1$instance<TContext> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbContextFactorySource_1: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextFactorySource_1: never;

    readonly Factory: Func_3<IServiceProvider, DbContextOptions_1<TContext>, TContext>;
}


export const DbContextFactorySource_1: {
    new<TContext extends unknown & DbContext>(): DbContextFactorySource_1<TContext>;
};


export interface __DbContextFactorySource_1$views<TContext extends unknown & DbContext> {
    As_IDbContextFactorySource_1(): IDbContextFactorySource_1$instance<TContext>;
}

export type DbContextFactorySource_1<TContext extends unknown & DbContext> = DbContextFactorySource_1$instance<TContext> & __DbContextFactorySource_1$views<TContext>;


export interface DbContextPool_1$instance<TContext extends unknown & DbContext> extends IDbContextPool_1<TContext>, IDbContextPool_1$instance<TContext>, System_Internal.IAsyncDisposable, System_Internal.IDisposable {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbContextPool_1: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextPool: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextPool_1: never;
    readonly __tsonic_iface_System_IAsyncDisposable: never;
    readonly __tsonic_iface_System_IDisposable: never;

    Dispose(): void;
    DisposeAsync(): ValueTask;
    Rent(): IDbContextPoolable;
    Return(context: IDbContextPoolable): void;
    ReturnAsync(context: IDbContextPoolable, cancellationToken?: CancellationToken): ValueTask;
}


export const DbContextPool_1: {
    new<TContext extends unknown & DbContext>(options: DbContextOptions_1<TContext>, serviceProvider: IServiceProvider | null): DbContextPool_1<TContext>;
    readonly DefaultPoolSize: int;
};


export interface __DbContextPool_1$views<TContext extends unknown & DbContext> {
    As_IDbContextPool(): IDbContextPool$instance;
}

export type DbContextPool_1<TContext extends unknown & DbContext> = DbContextPool_1$instance<TContext> & __DbContextPool_1$views<TContext>;


export interface DbContextPoolConfigurationSnapshot$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbContextPoolConfigurationSnapshot: never;

    readonly AutoDetectChangesEnabled: boolean;
    readonly AutoSavepointsEnabled: boolean;
    readonly AutoTransactionBehavior: AutoTransactionBehavior;
    readonly CascadeDeleteTiming: CascadeTiming;
    readonly DeleteOrphansTiming: CascadeTiming;
    readonly DetectedAllChanges: EventHandler_1<DetectedChangesEventArgs> | null;
    readonly DetectedEntityChanges: EventHandler_1<DetectedEntityChangesEventArgs> | null;
    readonly DetectingAllChanges: EventHandler_1<DetectChangesEventArgs> | null;
    readonly DetectingEntityChanges: EventHandler_1<DetectEntityChangesEventArgs> | null;
    readonly HasChangeDetectorConfiguration: boolean;
    readonly HasChangeTrackerConfiguration: boolean;
    readonly HasDatabaseConfiguration: boolean;
    readonly HasStateManagerConfiguration: boolean;
    readonly LazyLoadingEnabled: boolean;
    readonly QueryTrackingBehavior: Nullable_1<QueryTrackingBehavior>;
    readonly SaveChangesFailed: EventHandler_1<SaveChangesFailedEventArgs> | null;
    readonly SavedChanges: EventHandler_1<SavedChangesEventArgs> | null;
    readonly SavingChanges: EventHandler_1<SavingChangesEventArgs> | null;
    readonly StateChanged: EventHandler_1<EntityStateChangedEventArgs> | null;
    readonly StateChanging: EventHandler_1<EntityStateChangingEventArgs> | null;
    readonly Tracked: EventHandler_1<EntityTrackedEventArgs> | null;
    readonly Tracking: EventHandler_1<EntityTrackingEventArgs> | null;
}


export const DbContextPoolConfigurationSnapshot: {
    new(hasDatabaseConfiguration: boolean, hasStateManagerConfiguration: boolean, hasChangeTrackerConfiguration: boolean, hasChangeDetectorConfiguration: boolean, autoDetectChangesEnabled: boolean, queryTrackingBehavior: Nullable_1<QueryTrackingBehavior>, autoTransactionBehavior: AutoTransactionBehavior, autoSavepointsEnabled: boolean, lazyLoadingEnabled: boolean, cascadeDeleteTiming: CascadeTiming, deleteOrphansTiming: CascadeTiming, savingChanges: EventHandler_1<SavingChangesEventArgs> | null, savedChanges: EventHandler_1<SavedChangesEventArgs> | null, saveChangesFailed: EventHandler_1<SaveChangesFailedEventArgs> | null, tracking: EventHandler_1<EntityTrackingEventArgs> | null, tracked: EventHandler_1<EntityTrackedEventArgs> | null, stateChanging: EventHandler_1<EntityStateChangingEventArgs> | null, stateChanged: EventHandler_1<EntityStateChangedEventArgs> | null, detectingAllChanges: EventHandler_1<DetectChangesEventArgs> | null, detectedAllChanges: EventHandler_1<DetectedChangesEventArgs> | null, detectingEntityChanges: EventHandler_1<DetectEntityChangesEventArgs> | null, detectedEntityChanges: EventHandler_1<DetectedEntityChangesEventArgs> | null): DbContextPoolConfigurationSnapshot;
};


export type DbContextPoolConfigurationSnapshot = DbContextPoolConfigurationSnapshot$instance;

export interface DbContextServices$instance extends IDbContextServices$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbContextServices: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbContextServices: never;

    readonly ContextOptions: DbContextOptions;
    readonly CurrentContext: ICurrentDbContext;
    readonly DesignTimeModel: IModel;
    readonly InternalServiceProvider: IServiceProvider;
    readonly Model: IModel;
    Initialize(scopedProvider: IServiceProvider, contextOptions: DbContextOptions, context: DbContext): IDbContextServices;
}


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


export interface __DbContextServices$views {
    As_IDbContextServices(): IDbContextServices$instance;
}

export type DbContextServices = DbContextServices$instance & __DbContextServices$views;


export interface DbSetInitializer$instance extends IDbSetInitializer$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbSetInitializer: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbSetInitializer: never;

    InitializeSets(context: DbContext): void;
}


export const DbSetInitializer: {
    new(setFinder: IDbSetFinder, setSource: IDbSetSource): DbSetInitializer;
};


export interface __DbSetInitializer$views {
    As_IDbSetInitializer(): IDbSetInitializer$instance;
}

export type DbSetInitializer = DbSetInitializer$instance & __DbSetInitializer$views;


export interface DbSetSource$instance extends IDbSetSource$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_DbSetSource: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IDbSetSource: never;

    Create(context: DbContext, type: Type): unknown;
    Create(context: DbContext, name: string, type: Type): unknown;
}


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


export interface __DbSetSource$views {
    As_IDbSetSource(): IDbSetSource$instance;
}

export type DbSetSource = DbSetSource$instance & __DbSetSource$views;


export interface EntityFinder_1$instance<TEntity extends (object | null)> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_EntityFinder_1: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IEntityFinder: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IEntityFinder_1: never;

    Find(keyValues: (unknown | null)[] | null): TEntity | null;
    FindAsync(keyValues: (unknown | null)[] | null, cancellationToken?: CancellationToken): ValueTask_1<TEntity>;
    FindEntry<TKey extends unknown>(keyValue: TKey): InternalEntityEntry | null;
    FindEntry<TProperty extends unknown>(property: IProperty, propertyValue: TProperty): InternalEntityEntry | null;
    FindEntry(keyValues: IEnumerable_1<unknown | null>): InternalEntityEntry | null;
    FindEntry(properties: IEnumerable_1<IProperty>, propertyValues: IEnumerable_1<unknown | null>): InternalEntityEntry | null;
    GetDatabaseValues(entry: InternalEntityEntry): unknown[] | null;
    GetDatabaseValuesAsync(entry: InternalEntityEntry, cancellationToken?: CancellationToken): Task_1<unknown[] | null>;
    GetEntries<TProperty extends unknown>(property: IProperty, propertyValue: TProperty): IEnumerable_1<InternalEntityEntry>;
    GetEntries(properties: IEnumerable_1<IProperty>, propertyValues: IEnumerable_1<unknown | null>): IEnumerable_1<InternalEntityEntry>;
    Load(navigation: INavigation, entry: InternalEntityEntry, options: LoadOptions): void;
    LoadAsync(navigation: INavigation, entry: InternalEntityEntry, options: LoadOptions, cancellationToken?: CancellationToken): Task;
    Query(navigation: INavigation, entry: InternalEntityEntry): IQueryable_1<TEntity>;
}


export const EntityFinder_1: {
    new<TEntity extends (object | null)>(stateManager: IStateManager, setSource: IDbSetSource, setCache: IDbSetCache, entityType: IEntityType): EntityFinder_1<TEntity>;
};


export interface __EntityFinder_1$views<TEntity extends (object | null)> {
    As_IEntityFinder(): IEntityFinder$instance;
    As_IEntityFinder_1(): IEntityFinder_1$instance<TEntity>;
}

export type EntityFinder_1<TEntity extends (object | null)> = EntityFinder_1$instance<TEntity> & __EntityFinder_1$views<TEntity>;


export interface EntityFinderCollectionLoaderAdapter$instance extends ICollectionLoader$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_EntityFinderCollectionLoaderAdapter: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_ICollectionLoader: never;

    Load(entry: InternalEntityEntry, options: LoadOptions): void;
    LoadAsync(entry: InternalEntityEntry, options: LoadOptions, cancellationToken?: CancellationToken): Task;
    Query(entry: InternalEntityEntry): IQueryable;
}


export const EntityFinderCollectionLoaderAdapter: {
    new(entityFinder: IEntityFinder, navigation: INavigation): EntityFinderCollectionLoaderAdapter;
};


export interface __EntityFinderCollectionLoaderAdapter$views {
    As_ICollectionLoader(): ICollectionLoader$instance;
}

export type EntityFinderCollectionLoaderAdapter = EntityFinderCollectionLoaderAdapter$instance & __EntityFinderCollectionLoaderAdapter$views;


export interface EntityFinderFactory$instance extends IEntityFinderFactory$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_EntityFinderFactory: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IEntityFinderFactory: never;

    Create(type: IEntityType): IEntityFinder;
}


export const EntityFinderFactory: {
    new(entityFinderSource: IEntityFinderSource, stateManager: IStateManager, setSource: IDbSetSource, setCache: IDbSetCache): EntityFinderFactory;
};


export interface __EntityFinderFactory$views {
    As_IEntityFinderFactory(): IEntityFinderFactory$instance;
}

export type EntityFinderFactory = EntityFinderFactory$instance & __EntityFinderFactory$views;


export interface EntityFinderSource$instance extends IEntityFinderSource$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_EntityFinderSource: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IEntityFinderSource: never;

    Create(stateManager: IStateManager, setSource: IDbSetSource, setCache: IDbSetCache, type: IEntityType): IEntityFinder;
}


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


export interface __EntityFinderSource$views {
    As_IEntityFinderSource(): IEntityFinderSource$instance;
}

export type EntityFinderSource = EntityFinderSource$instance & __EntityFinderSource$views;


export interface InternalDbSet_1$instance<TEntity extends (object | null)> extends DbSet_1<TEntity>, Microsoft_EntityFrameworkCore_Infrastructure_Internal.IInfrastructure_1$instance<IServiceProvider>, Microsoft_EntityFrameworkCore_Infrastructure_Internal.IResettableService$instance, System_Collections_Generic_Internal.IAsyncEnumerable_1<TEntity>, System_Collections_Generic_Internal.IEnumerable_1<TEntity>, System_ComponentModel_Internal.IListSource, System_Linq_Internal.IQueryable_1<TEntity> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_InternalDbSet_1: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IInfrastructure_1: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IResettableService: never;
    readonly __tsonic_iface_System_Collections_Generic_IAsyncEnumerable_1: never;
    readonly __tsonic_iface_System_Collections_Generic_IEnumerable_1: never;
    readonly __tsonic_iface_System_Collections_IEnumerable: never;
    readonly __tsonic_iface_System_ComponentModel_IListSource: never;
    readonly __tsonic_iface_System_Linq_IQueryable: never;
    readonly __tsonic_iface_System_Linq_IQueryable_1: never;

    readonly EntityType: IEntityType;
    readonly Local: LocalView_1<TEntity>;
    Add(entity: TEntity): EntityEntry_1<TEntity>;
    AddAsync(entity: TEntity, cancellationToken?: CancellationToken): ValueTask_1<EntityEntry_1<TEntity>>;
    AddRange(...entities: TEntity[]): void;
    AddRange(entities: IEnumerable_1<TEntity>): void;
    AddRangeAsync(...entities: TEntity[]): Task;
    AddRangeAsync(entities: IEnumerable_1<TEntity>, cancellationToken?: CancellationToken): Task;
    Attach(entity: TEntity): EntityEntry_1<TEntity>;
    AttachRange(...entities: TEntity[]): void;
    AttachRange(entities: IEnumerable_1<TEntity>): void;
    Entry(entity: TEntity): EntityEntry_1<TEntity>;
    Find(...keyValues: (unknown | null)[]): TEntity | null;
    Find(keyValues: (unknown | null)[] | null): TEntity | null;
    FindAsync(...keyValues: (unknown | null)[]): ValueTask_1<TEntity>;
    FindAsync(keyValues: (unknown | null)[] | null): ValueTask_1<TEntity>;
    FindAsync(keyValues: (unknown | null)[] | null, cancellationToken: CancellationToken): ValueTask_1<TEntity>;
    Remove(entity: TEntity): EntityEntry_1<TEntity>;
    RemoveRange(...entities: TEntity[]): void;
    RemoveRange(entities: IEnumerable_1<TEntity>): void;
    Update(entity: TEntity): EntityEntry_1<TEntity>;
    UpdateRange(...entities: TEntity[]): void;
    UpdateRange(entities: IEnumerable_1<TEntity>): void;
}


export const InternalDbSet_1: {
    new<TEntity extends (object | null)>(context: DbContext, entityTypeName: string | null): InternalDbSet_1<TEntity>;
};


export interface __InternalDbSet_1$views<TEntity extends (object | null)> {
    As_IInfrastructure_1(): Microsoft_EntityFrameworkCore_Infrastructure_Internal.IInfrastructure_1$instance<IServiceProvider>;
    As_IResettableService(): Microsoft_EntityFrameworkCore_Infrastructure_Internal.IResettableService$instance;
}

export type InternalDbSet_1<TEntity extends (object | null)> = InternalDbSet_1$instance<TEntity> & __InternalDbSet_1$views<TEntity>;


export interface ManyToManyLoader_2$instance<TEntity extends (object | null), TSourceEntity extends (object | null)> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_ManyToManyLoader_2: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_ICollectionLoader: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_ICollectionLoader_1: never;

    Load(entry: InternalEntityEntry, options: LoadOptions): void;
    LoadAsync(entry: InternalEntityEntry, options: LoadOptions, cancellationToken?: CancellationToken): Task;
    Query(entry: InternalEntityEntry): IQueryable_1<TEntity>;
}


export const ManyToManyLoader_2: {
    new<TEntity extends (object | null), TSourceEntity extends (object | null)>(skipNavigation: ISkipNavigation): ManyToManyLoader_2<TEntity, TSourceEntity>;
};


export interface __ManyToManyLoader_2$views<TEntity extends (object | null), TSourceEntity extends (object | null)> {
    As_ICollectionLoader(): ICollectionLoader$instance;
    As_ICollectionLoader_1(): ICollectionLoader_1$instance<TEntity>;
}

export type ManyToManyLoader_2<TEntity extends (object | null), TSourceEntity extends (object | null)> = ManyToManyLoader_2$instance<TEntity, TSourceEntity> & __ManyToManyLoader_2$views<TEntity, TSourceEntity>;


export interface ManyToManyLoaderFactory$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_ManyToManyLoaderFactory: never;

    Create(skipNavigation: ISkipNavigation): ICollectionLoader;
}


export const ManyToManyLoaderFactory: {
    readonly Instance: ManyToManyLoaderFactory;
};


export type ManyToManyLoaderFactory = ManyToManyLoaderFactory$instance;

export interface NullableComparerAdapter_1$instance<TNullableKey extends unknown> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_NullableComparerAdapter_1: never;

    readonly __tsonic_iface_System_Collections_Generic_IEqualityComparer_1: never;

    Equals(x: TNullableKey | null, y: TNullableKey | null): boolean;
    GetHashCode(obj: TNullableKey): int;
}


export const NullableComparerAdapter_1: {
    Wrap<TNullableKey extends unknown>(comparer: IEqualityComparer, valueConverter?: ValueConverter | null): IEqualityComparer_1<TNullableKey>;
};


export type NullableComparerAdapter_1<TNullableKey extends unknown> = NullableComparerAdapter_1$instance<TNullableKey>;

export interface RegisteredServices$instance extends IRegisteredServices$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_RegisteredServices: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IRegisteredServices: never;

    readonly Services: ISet_1<Type>;
}


export const RegisteredServices: {
    new(services: IEnumerable_1<Type>): RegisteredServices;
};


export interface __RegisteredServices$views {
    As_IRegisteredServices(): IRegisteredServices$instance;
}

export type RegisteredServices = RegisteredServices$instance & __RegisteredServices$views;


export interface ScopedDbContextLease_1$instance<TContext extends unknown & DbContext> extends IScopedDbContextLease_1$instance<TContext>, System_Internal.IAsyncDisposable, System_Internal.IDisposable {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_ScopedDbContextLease_1: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_IScopedDbContextLease_1: never;
    readonly __tsonic_iface_System_IAsyncDisposable: never;
    readonly __tsonic_iface_System_IDisposable: never;

    readonly Context: TContext;
}


export const ScopedDbContextLease_1: {
    new<TContext extends unknown & DbContext>(contextPool: IDbContextPool_1<TContext>): ScopedDbContextLease_1<TContext>;
};


export interface __ScopedDbContextLease_1$views<TContext extends unknown & DbContext> {
    As_IScopedDbContextLease_1(): IScopedDbContextLease_1$instance<TContext>;
}

export type ScopedDbContextLease_1<TContext extends unknown & DbContext> = ScopedDbContextLease_1$instance<TContext> & __ScopedDbContextLease_1$views<TContext>;


export interface SemanticVersionComparer$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_SemanticVersionComparer: never;

    readonly __tsonic_iface_System_Collections_Generic_IComparer_1: never;

    Compare(x: string | null, y: string | null): int;
}


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


export type SemanticVersionComparer = SemanticVersionComparer$instance;

export interface ServiceProviderCache$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_ServiceProviderCache: never;

    GetOrAdd(options: IDbContextOptions, providerRequired: boolean): IServiceProvider;
}


export const ServiceProviderCache: {
    new(): ServiceProviderCache;
    readonly Instance: ServiceProviderCache;
};


export type ServiceProviderCache = ServiceProviderCache$instance;

export interface SingletonOptionsInitializer$instance extends ISingletonOptionsInitializer$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_SingletonOptionsInitializer: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Internal_ISingletonOptionsInitializer: never;

    EnsureInitialized(serviceProvider: IServiceProvider, options: IDbContextOptions): void;
}


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


export interface __SingletonOptionsInitializer$views {
    As_ISingletonOptionsInitializer(): ISingletonOptionsInitializer$instance;
}

export type SingletonOptionsInitializer = SingletonOptionsInitializer$instance & __SingletonOptionsInitializer$views;


export interface TypeFullNameComparer$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Internal_TypeFullNameComparer: never;

    readonly __tsonic_iface_System_Collections_Generic_IComparer_1: never;
    readonly __tsonic_iface_System_Collections_Generic_IEqualityComparer_1: never;

    Compare(x: Type | null, y: Type | null): int;
    Equals(x: Type | null, y: Type | null): boolean;
    GetHashCode(obj: Type): int;
}


export const TypeFullNameComparer: {
    readonly Instance: TypeFullNameComparer;
};


export type TypeFullNameComparer = TypeFullNameComparer$instance;

export abstract class DbContextDependenciesExtensions$instance {
    static GetDependencies(currentContext: ICurrentDbContext): IDbContextDependencies;
    static GetDependencies(context: IDbContextDependencies): IDbContextDependencies;
}


export type DbContextDependenciesExtensions = DbContextDependenciesExtensions$instance;

export abstract class DbContextExtensions$instance {
    static ConfigureConventions(context: DbContext, configurationBuilder: ModelConfigurationBuilder): void;
}


export type DbContextExtensions = DbContextExtensions$instance;

export abstract class EntityTypeExtensions$instance {
    static IsAdHoc(entityType: IEntityType): boolean;
}


export type EntityTypeExtensions = EntityTypeExtensions$instance;

export abstract class ExpressionExtensions$instance {
    static BuildPredicate(keyProperties: IReadOnlyList_1<IReadOnlyProperty>, keyValues: ValueBuffer, entityParameter: ParameterExpression): Expression;
    static GetLambdaOrNull(expression: Expression): LambdaExpression | null;
    static IsLogicalNot(sqlUnaryExpression: UnaryExpression): boolean;
    static IsLogicalOperation(expression: Expression): boolean;
    static MakeHasSentinel(currentValueExpression: Expression, propertyBase: IReadOnlyPropertyBase | null): Expression;
    static MatchMemberAccessList<TMemberInfo extends unknown & MemberInfo>(lambdaExpression: LambdaExpression, memberMatcher: Func_3<Expression, Expression, TMemberInfo | null>): IReadOnlyList_1<TMemberInfo> | null;
    static MatchSimpleMemberAccess<TMemberInfo extends unknown & MemberInfo>(parameterExpression: Expression, memberAccessExpression: Expression): TMemberInfo | null;
    static RemoveTypeAs(expression: Expression | null): Expression | null;
}


export type ExpressionExtensions = ExpressionExtensions$instance;

export abstract class MethodInfoExtensions$instance {
    static MethodIsClosedFormOf(methodInfo: MethodInfo, genericMethod: MethodInfo): boolean;
}


export type MethodInfoExtensions = MethodInfoExtensions$instance;

export abstract class MethodInfoExtensions2$instance {
    static DisplayName(methodInfo: MethodInfo): string;
}


export type MethodInfoExtensions2 = MethodInfoExtensions2$instance;

export abstract class RelationalCommandResolverExtensions$instance {
    static RentAndPopulateRelationalCommand(relationalCommandResolver: RelationalCommandResolver, queryContext: RelationalQueryContext): IRelationalCommand;
}


export type RelationalCommandResolverExtensions = RelationalCommandResolverExtensions$instance;

export abstract class RelationalModelExtensions$instance {
    static EnsureRelationalModel(model: IModel): void;
}


export type RelationalModelExtensions = RelationalModelExtensions$instance;

export abstract class TupleExtensions$instance {
    static FormatTable(table: ValueTuple_2<System_Internal.String, System_Internal.String>): string;
    static FormatTables(tables: IEnumerable_1<ValueTuple_2<System_Internal.String, System_Internal.String>>): string;
}


export type TupleExtensions = TupleExtensions$instance;

export abstract class TypeBaseExtensions$instance {
    static DisplayName(entityType: TypeBase): string;
    static GetComplexProperty(type: ITypeBase, name: string): IComplexProperty;
    static GetOwnedName(type: IReadOnlyTypeBase, simpleName: string, ownershipNavigation: string): string;
    static GetRuntimeFields(type: IReadOnlyTypeBase): IReadOnlyDictionary_2<System_Internal.String, FieldInfo>;
    static GetRuntimeProperties(type: IReadOnlyTypeBase): IReadOnlyDictionary_2<System_Internal.String, PropertyInfo>;
    static ShortName(entityType: TypeBase): string;
}


export type TypeBaseExtensions = TypeBaseExtensions$instance;

export abstract class TypeExtensions$instance {
    static FindIndexerProperty(type: Type): PropertyInfo | null;
    static GenerateParameterName(type: Type): string;
    static GetFieldInfo(type: Type, fieldName: string): FieldInfo | null;
    static IsDefaultValue(type: Type, value: unknown | null): boolean;
}


export type TypeExtensions = TypeExtensions$instance;