@tsonic/efcore 10.0.3 → 10.0.8

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

@@ -23,19 +23,19 @@ import type { ExecutionStrategyDependencies, IDatabaseFacadeDependencies, IDatab
 import type { IRowForeignKeyValueFactoryFactory, IRowIndexValueFactoryFactory, IRowKeyValueFactoryFactory } from "../../Microsoft.EntityFrameworkCore.Update.Internal/internal/index.js";
 import * as Microsoft_EntityFrameworkCore_Internal from "../../Microsoft.EntityFrameworkCore/internal/index.js";
 import type { AutoTransactionBehavior, DbContext, DbContextOptions_1, DbContextOptionsBuilder, DbLoggerCategory_Model, DbLoggerCategory_Model_Validation, IDbContextFactory_1, ModelBuilder, ModelCreationDependencies, ParameterTranslationMode, QuerySplittingBehavior, QueryTrackingBehavior } from "../../Microsoft.EntityFrameworkCore/internal/index.js";
-import type { IDictionary, IEnumerable, IReadOnlyDictionary, IReadOnlyList, ISet } from "@tsonic/dotnet/System.Collections.Generic.js";
-import type { DbConnection } from "@tsonic/dotnet/System.Data.Common.js";
-import * as System_Diagnostics_Tracing_Internal from "@tsonic/dotnet/System.Diagnostics.Tracing.js";
-import type { EventCommandEventArgs, EventSource } from "@tsonic/dotnet/System.Diagnostics.Tracing.js";
-import * as System_Internal from "@tsonic/dotnet/System.js";
-import type { Action, Attribute, Boolean as ClrBoolean, Char, Enum, FormattableString, Func, IComparable, IConvertible, IDisposable, IEquatable, IFormattable, Int32, IServiceProvider, ISpanFormattable, Nullable, Object as ClrObject, String as ClrString, TimeSpan, Type, ValueTuple, ValueType, Void } from "@tsonic/dotnet/System.js";
-import type { Expression, LambdaExpression, MemberExpression, MethodCallExpression } from "@tsonic/dotnet/System.Linq.Expressions.js";
-import type { Assembly, MemberInfo, MethodInfo, PropertyInfo } from "@tsonic/dotnet/System.Reflection.js";
-import type { CancellationToken } from "@tsonic/dotnet/System.Threading.js";
-import type { Task } from "@tsonic/dotnet/System.Threading.Tasks.js";
-import type { IMemoryCache } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Caching.Memory.js";
-import type { IServiceCollection, ServiceLifetime } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection.js";
-import type { ILoggerFactory } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging.js";
+import type { IDictionary_2, IEnumerable_1, IReadOnlyDictionary_2, IReadOnlyList_1, ISet_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
+import type { DbConnection } from "@tsonic/dotnet/System.Data.Common/internal/index.js";
+import * as System_Diagnostics_Tracing_Internal from "@tsonic/dotnet/System.Diagnostics.Tracing/internal/index.js";
+import type { EventCommandEventArgs, EventSource } from "@tsonic/dotnet/System.Diagnostics.Tracing/internal/index.js";
+import type { Expression, LambdaExpression, MemberExpression, MethodCallExpression } from "@tsonic/dotnet/System.Linq.Expressions/internal/index.js";
+import type { Assembly, MemberInfo, MethodInfo, PropertyInfo } from "@tsonic/dotnet/System.Reflection/internal/index.js";
+import type { Task, Task_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 { Action_1, Action_2, Attribute, Boolean as ClrBoolean, Char, Enum, FormattableString, Func_1, Func_2, Func_4, IComparable, IConvertible, IDisposable, IEquatable_1, IFormattable, Int32, IServiceProvider, ISpanFormattable, Nullable_1, Object as ClrObject, String as ClrString, TimeSpan, Type, ValueTuple_2, ValueType, Void } from "@tsonic/dotnet/System/internal/index.js";
+import type { IMemoryCache } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Caching.Memory/internal/index.js";
+import type { IServiceCollection, ServiceLifetime } from "@tsonic/microsoft-extensions/Microsoft.Extensions.DependencyInjection/internal/index.js";
+import type { ILoggerFactory } from "@tsonic/microsoft-extensions/Microsoft.Extensions.Logging/internal/index.js";
 
 export enum MetadataDebugStringOptions {
     IncludeAnnotations = 1,
@@ -48,15 +48,17 @@ export enum MetadataDebugStringOptions {
 
 
 export interface IAnnotatable$instance extends IReadOnlyAnnotatable {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IAnnotatable: never;
+
     readonly [name: string]: unknown | undefined;
     AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
     AnnotationsToDebugString(indent?: int): string;
     FindRuntimeAnnotation(name: string): IAnnotation | undefined;
     FindRuntimeAnnotationValue(name: string): unknown | undefined;
-    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func<TArg, TValue>, factoryArgument: TArg): TValue;
-    GetRuntimeAnnotations(): IEnumerable<IAnnotation>;
+    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func_2<TArg, TValue>, factoryArgument: TArg): TValue;
+    GetRuntimeAnnotations(): IEnumerable_1<IAnnotation>;
     FindAnnotation(name: string): IAnnotation | undefined;
-    GetAnnotations(): IEnumerable<IAnnotation>;
+    GetAnnotations(): IEnumerable_1<IAnnotation>;
 }
 
 
@@ -65,6 +67,8 @@ export interface IAnnotatable$instance extends IReadOnlyAnnotatable$instance {}
 export type IAnnotatable = IAnnotatable$instance;
 
 export interface IAnnotation$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IAnnotation: never;
+
     readonly Name: string;
     readonly Value: unknown | undefined;
 }
@@ -73,6 +77,8 @@ export interface IAnnotation$instance {
 export type IAnnotation = IAnnotation$instance;
 
 export interface IConcurrencyDetector$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IConcurrencyDetector: never;
+
     EnterCriticalSection(): ConcurrencyDetectorCriticalSectionDisposer;
     ExitCriticalSection(): void;
 }
@@ -81,6 +87,8 @@ export interface IConcurrencyDetector$instance {
 export type IConcurrencyDetector = IConcurrencyDetector$instance;
 
 export interface ICoreSingletonOptions$instance extends ISingletonOptions {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_ICoreSingletonOptions: never;
+
     readonly AreDetailedErrorsEnabled: boolean;
     readonly AreThreadSafetyChecksEnabled: boolean;
     readonly RootApplicationServiceProvider: IServiceProvider | undefined;
@@ -93,6 +101,8 @@ export interface ICoreSingletonOptions$instance extends ISingletonOptions$instan
 export type ICoreSingletonOptions = ICoreSingletonOptions$instance;
 
 export interface ICurrentDbContext$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_ICurrentDbContext: never;
+
     readonly Context: DbContext;
 }
 
@@ -100,7 +110,9 @@ export interface ICurrentDbContext$instance {
 export type ICurrentDbContext = ICurrentDbContext$instance;
 
 export interface IDbContextOptions$instance {
-    readonly Extensions: IEnumerable<IDbContextOptionsExtension>;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptions: never;
+
+    readonly Extensions: IEnumerable_1<IDbContextOptionsExtension>;
     FindExtension<TExtension extends IDbContextOptionsExtension>(): TExtension | undefined;
 }
 
@@ -108,6 +120,8 @@ export interface IDbContextOptions$instance {
 export type IDbContextOptions = IDbContextOptions$instance;
 
 export interface IDbContextOptionsBuilderInfrastructure$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptionsBuilderInfrastructure: never;
+
     AddOrUpdateExtension<TExtension extends IDbContextOptionsExtension>(extension: TExtension): void;
 }
 
@@ -115,6 +129,8 @@ export interface IDbContextOptionsBuilderInfrastructure$instance {
 export type IDbContextOptionsBuilderInfrastructure = IDbContextOptionsBuilderInfrastructure$instance;
 
 export interface IDbContextOptionsConfiguration_1$instance<TContext extends DbContext> {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptionsConfiguration_1: never;
+
     Configure(serviceProvider: IServiceProvider, optionsBuilder: DbContextOptionsBuilder): void;
 }
 
@@ -122,6 +138,8 @@ export interface IDbContextOptionsConfiguration_1$instance<TContext extends DbCo
 export type IDbContextOptionsConfiguration_1<TContext extends DbContext> = IDbContextOptionsConfiguration_1$instance<TContext>;
 
 export interface IDbContextOptionsExtension$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptionsExtension: never;
+
     readonly Info: DbContextOptionsExtensionInfo;
     ApplyDefaults(options: IDbContextOptions): IDbContextOptionsExtension;
     ApplyServices(services: IServiceCollection): void;
@@ -132,13 +150,17 @@ export interface IDbContextOptionsExtension$instance {
 export type IDbContextOptionsExtension = IDbContextOptionsExtension$instance;
 
 export interface IDbSetFinder$instance {
-    FindSets(contextType: Type): IReadOnlyList<DbSetProperty>;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbSetFinder: never;
+
+    FindSets(contextType: Type): IReadOnlyList_1<DbSetProperty>;
 }
 
 
 export type IDbSetFinder = IDbSetFinder$instance;
 
 export interface IInfrastructure_1$instance<T> {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IInfrastructure_1: never;
+
     readonly Instance: T;
 }
 
@@ -146,6 +168,8 @@ export interface IInfrastructure_1$instance<T> {
 export type IInfrastructure_1<T> = IInfrastructure_1$instance<T>;
 
 export interface IInternalServiceCollectionMap$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IInternalServiceCollectionMap: never;
+
     AddDependencySingleton<TDependencies>(): IInternalServiceCollectionMap;
 }
 
@@ -153,6 +177,8 @@ export interface IInternalServiceCollectionMap$instance {
 export type IInternalServiceCollectionMap = IInternalServiceCollectionMap$instance;
 
 export interface ILazyLoader$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_ILazyLoader: never;
+
     Dispose(): void;
     IsLoaded(entity: unknown, navigationName?: string): boolean;
     Load(entity: unknown, navigationName?: string): void;
@@ -164,6 +190,8 @@ export interface ILazyLoader$instance {
 export type ILazyLoader = ILazyLoader$instance;
 
 export interface IModelCacheKeyFactory$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelCacheKeyFactory: never;
+
     Create(context: DbContext, designTime: boolean): unknown;
 }
 
@@ -171,6 +199,8 @@ export interface IModelCacheKeyFactory$instance {
 export type IModelCacheKeyFactory = IModelCacheKeyFactory$instance;
 
 export interface IModelCustomizer$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelCustomizer: never;
+
     Customize(modelBuilder: ModelBuilder, context: DbContext): void;
 }
 
@@ -178,6 +208,8 @@ export interface IModelCustomizer$instance {
 export type IModelCustomizer = IModelCustomizer$instance;
 
 export interface IModelRuntimeInitializer$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelRuntimeInitializer: never;
+
     Initialize(model: IModel, designTime?: boolean, validationLogger?: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): IModel;
 }
 
@@ -185,6 +217,8 @@ export interface IModelRuntimeInitializer$instance {
 export type IModelRuntimeInitializer = IModelRuntimeInitializer$instance;
 
 export interface IModelSource$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelSource: never;
+
     GetModel(context: DbContext, modelCreationDependencies: ModelCreationDependencies, designTime: boolean): IModel;
 }
 
@@ -192,6 +226,8 @@ export interface IModelSource$instance {
 export type IModelSource = IModelSource$instance;
 
 export interface IModelValidator$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelValidator: never;
+
     Validate(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
 }
 
@@ -199,16 +235,20 @@ export interface IModelValidator$instance {
 export type IModelValidator = IModelValidator$instance;
 
 export interface IReadOnlyAnnotatable$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IReadOnlyAnnotatable: never;
+
     readonly [name: string]: unknown | undefined;
     AnnotationsToDebugString(indent?: int): string;
     FindAnnotation(name: string): IAnnotation | undefined;
-    GetAnnotations(): IEnumerable<IAnnotation>;
+    GetAnnotations(): IEnumerable_1<IAnnotation>;
 }
 
 
 export type IReadOnlyAnnotatable = IReadOnlyAnnotatable$instance;
 
 export interface IRelationalDbContextOptionsBuilderInfrastructure$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IRelationalDbContextOptionsBuilderInfrastructure: never;
+
     readonly OptionsBuilder: DbContextOptionsBuilder;
 }
 
@@ -216,6 +256,8 @@ export interface IRelationalDbContextOptionsBuilderInfrastructure$instance {
 export type IRelationalDbContextOptionsBuilderInfrastructure = IRelationalDbContextOptionsBuilderInfrastructure$instance;
 
 export interface IResettableService$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IResettableService: never;
+
     ResetState(): void;
     ResetStateAsync(cancellationToken?: CancellationToken): Task;
 }
@@ -224,6 +266,8 @@ export interface IResettableService$instance {
 export type IResettableService = IResettableService$instance;
 
 export interface ISingletonOptions$instance {
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_ISingletonOptions: never;
+
     Initialize(options: IDbContextOptions): void;
 }
 
@@ -231,6 +275,10 @@ export interface ISingletonOptions$instance {
 export type ISingletonOptions = ISingletonOptions$instance;
 
 export interface ConcurrencyDetectorCriticalSectionDisposer$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ConcurrencyDetectorCriticalSectionDisposer: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     Dispose(): void;
 }
 
@@ -243,6 +291,8 @@ export const ConcurrencyDetectorCriticalSectionDisposer: {
 export type ConcurrencyDetectorCriticalSectionDisposer = ConcurrencyDetectorCriticalSectionDisposer$instance;
 
 export interface DbSetProperty$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_DbSetProperty: never;
+
     readonly Name: string;
     readonly Setter: IClrPropertySetter | undefined;
     readonly Type: Type;
@@ -257,6 +307,8 @@ export const DbSetProperty: {
 export type DbSetProperty = DbSetProperty$instance;
 
 export interface ServiceCharacteristics$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ServiceCharacteristics: never;
+
     readonly Lifetime: ServiceLifetime;
     readonly MultipleRegistrations: boolean;
 }
@@ -270,10 +322,16 @@ export const ServiceCharacteristics: {
 export type ServiceCharacteristics = ServiceCharacteristics$instance;
 
 export interface Annotatable$instance extends AnnotatableBase$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_Annotatable: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IAnnotatable: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IReadOnlyAnnotatable: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableAnnotatable: never;
+
     AddAnnotation(name: string, value: unknown): Annotation;
     AddAnnotation(name: string, annotation: Annotation): Annotation;
-    AddAnnotations(annotations: IEnumerable<IAnnotation>): void;
-    AddAnnotations(annotations: IReadOnlyDictionary<System_Internal.String, unknown>): void;
+    AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
+    AddAnnotations(annotations: IReadOnlyDictionary_2<System_Internal.String, unknown>): void;
     AddRuntimeAnnotation(name: string, value: unknown): Annotation;
     AddRuntimeAnnotation(name: string, annotation: Annotation): Annotation;
     AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
@@ -285,9 +343,9 @@ export interface Annotatable$instance extends AnnotatableBase$instance {
     FindRuntimeAnnotation(name: string): Annotation | undefined;
     FindRuntimeAnnotation(name: string): IAnnotation | undefined;
     FindRuntimeAnnotationValue(name: string): unknown | undefined;
-    GetAnnotations(): IEnumerable<Annotation>;
-    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func<TArg, TValue>, factoryArgument: TArg): TValue;
-    GetRuntimeAnnotations(): IEnumerable<Annotation>;
+    GetAnnotations(): IEnumerable_1<Annotation>;
+    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func_2<TArg, TValue>, factoryArgument: TArg): TValue;
+    GetRuntimeAnnotations(): IEnumerable_1<Annotation>;
     RemoveAnnotation(name: string): Annotation | undefined;
     SetAnnotation(name: string, value: unknown): void;
     SetAnnotation(name: string, annotation: Annotation, oldAnnotation: Annotation): Annotation | undefined;
@@ -309,16 +367,21 @@ export type Annotatable = Annotatable$instance & __Annotatable$views;
 
 
 export interface AnnotatableBase$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_AnnotatableBase: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IAnnotatable: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IReadOnlyAnnotatable: never;
+
     readonly IsReadOnly: boolean;
     [name: string]: unknown | undefined;
     AddAnnotation(name: string, value: unknown): Annotation;
     AddAnnotation(name: string, annotation: Annotation): Annotation;
-    AddAnnotations(annotations: IEnumerable<IAnnotation>): void;
-    AddAnnotations(annotations: IReadOnlyDictionary<System_Internal.String, unknown>): void;
+    AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
+    AddAnnotations(annotations: IReadOnlyDictionary_2<System_Internal.String, unknown>): void;
     AddRuntimeAnnotation(name: string, value: unknown): Annotation;
     AddRuntimeAnnotation(name: string, annotation: Annotation): Annotation;
-    AddRuntimeAnnotations(annotations: IEnumerable<Annotation>): void;
-    AddRuntimeAnnotations(annotations: IReadOnlyDictionary<System_Internal.String, unknown>): void;
+    AddRuntimeAnnotations(annotations: IEnumerable_1<Annotation>): void;
+    AddRuntimeAnnotations(annotations: IReadOnlyDictionary_2<System_Internal.String, unknown>): void;
     CreateAnnotation(name: string, value: unknown): Annotation;
     CreateRuntimeAnnotation(name: string, value: unknown): Annotation;
     EnsureMutable(): void;
@@ -326,9 +389,9 @@ export interface AnnotatableBase$instance {
     FindAnnotation(name: string): Annotation | undefined;
     FindRuntimeAnnotation(name: string): Annotation | undefined;
     GetAnnotation(annotationName: string): Annotation;
-    GetAnnotations(): IEnumerable<Annotation>;
-    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func<TArg, TValue>, factoryArgument: TArg): TValue;
-    GetRuntimeAnnotations(): IEnumerable<Annotation>;
+    GetAnnotations(): IEnumerable_1<Annotation>;
+    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func_2<TArg, TValue>, factoryArgument: TArg): TValue;
+    GetRuntimeAnnotations(): IEnumerable_1<Annotation>;
     OnAnnotationSet(name: string, annotation: Annotation, oldAnnotation: Annotation): Annotation | undefined;
     RemoveAnnotation(name: string): Annotation | undefined;
     RemoveRuntimeAnnotation(name: string): Annotation | undefined;
@@ -353,8 +416,12 @@ export type AnnotatableBase = AnnotatableBase$instance & __AnnotatableBase$views
 
 
 export interface AnnotatableBuilder_2$instance<TMetadata extends ConventionAnnotatable, TModelBuilder extends IConventionModelBuilder> {
-    readonly Metadata: ComplexType | TMetadata;
-    readonly ModelBuilder: InternalModelBuilder | TModelBuilder;
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_AnnotatableBuilder_2: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_Builders_IConventionAnnotatableBuilder: never;
+
+    readonly Metadata: TMetadata;
+    readonly ModelBuilder: TModelBuilder;
     CanRemoveAnnotation(name: string, configurationSource: ConfigurationSource): boolean;
     CanSetAnnotation(name: string, value: unknown, configurationSource: ConfigurationSource): boolean;
     HasAnnotation(name: string, value: unknown, configurationSource: ConfigurationSource): AnnotatableBuilder_2<TMetadata, TModelBuilder> | undefined;
@@ -377,7 +444,11 @@ export interface __AnnotatableBuilder_2$views<TMetadata extends ConventionAnnota
 export type AnnotatableBuilder_2<TMetadata extends ConventionAnnotatable, TModelBuilder extends IConventionModelBuilder> = AnnotatableBuilder_2$instance<TMetadata, TModelBuilder> & __AnnotatableBuilder_2$views<TMetadata, TModelBuilder>;
 
 
-export interface Annotation$instance {
+export interface Annotation$instance extends IAnnotation$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_Annotation: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IAnnotation: never;
+
     readonly Name: string;
     readonly Value: unknown | undefined;
 }
@@ -392,17 +463,22 @@ export interface __Annotation$views {
     As_IAnnotation(): IAnnotation$instance;
 }
 
-export interface Annotation$instance extends IAnnotation$instance {}
-
 export type Annotation = Annotation$instance & __Annotation$views;
 
 
 export interface ConventionAnnotatable$instance extends Annotatable$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ConventionAnnotatable: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IAnnotatable: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IReadOnlyAnnotatable: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IConventionAnnotatable: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Metadata_IMutableAnnotatable: never;
+
     AddAnnotation(name: string, value: unknown): IAnnotation;
     AddAnnotation(name: string, value: unknown): Annotation;
     AddAnnotation(name: string, annotation: Annotation): Annotation;
-    AddAnnotations(annotations: IEnumerable<IAnnotation>): void;
-    AddAnnotations(annotations: IReadOnlyDictionary<System_Internal.String, unknown>): void;
+    AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
+    AddAnnotations(annotations: IReadOnlyDictionary_2<System_Internal.String, unknown>): void;
     AddRuntimeAnnotation(name: string, value: unknown): IAnnotation;
     AddRuntimeAnnotation(name: string, value: unknown): Annotation;
     AddRuntimeAnnotation(name: string, annotation: Annotation): Annotation;
@@ -413,9 +489,9 @@ export interface ConventionAnnotatable$instance extends Annotatable$instance {
     FindRuntimeAnnotation(name: string): IAnnotation | undefined;
     FindRuntimeAnnotation(name: string): Annotation | undefined;
     FindRuntimeAnnotationValue(name: string): unknown | undefined;
-    GetAnnotations(): IEnumerable<IAnnotation>;
-    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func<TArg, TValue>, factoryArgument: TArg): TValue;
-    GetRuntimeAnnotations(): IEnumerable<IAnnotation>;
+    GetAnnotations(): IEnumerable_1<IAnnotation>;
+    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func_2<TArg, TValue>, factoryArgument: TArg): TValue;
+    GetRuntimeAnnotations(): IEnumerable_1<IAnnotation>;
     OnAnnotationSet(name: string, annotation: Annotation, oldAnnotation: Annotation): Annotation | undefined;
     OnAnnotationSet(name: string, annotation: IConventionAnnotation, oldAnnotation: IConventionAnnotation): IConventionAnnotation | undefined;
     RemoveAnnotation(name: string): IAnnotation | undefined;
@@ -440,51 +516,55 @@ export interface __ConventionAnnotatable$views {
 export type ConventionAnnotatable = ConventionAnnotatable$instance & __ConventionAnnotatable$views;
 
 
-export interface CoreOptionsExtension$instance {
+export interface CoreOptionsExtension$instance extends IDbContextOptionsExtension$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_CoreOptionsExtension: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptionsExtension: never;
+
     readonly ApplicationServiceProvider: IServiceProvider | undefined;
-    readonly AsyncSeeder: Func<DbContext, System_Internal.Boolean, CancellationToken, Task> | undefined;
+    readonly AsyncSeeder: Func_4<DbContext, System_Internal.Boolean, CancellationToken, Task> | undefined;
     readonly AutoResolveRootProvider: boolean;
     readonly DbContextLogger: IDbContextLogger | undefined;
     readonly DetailedErrorsEnabled: boolean;
     readonly Info: DbContextOptionsExtensionInfo;
-    readonly Interceptors: IEnumerable<IInterceptor> | undefined;
+    readonly Interceptors: IEnumerable_1<IInterceptor> | undefined;
     readonly InternalServiceProvider: IServiceProvider | undefined;
     readonly IsSensitiveDataLoggingEnabled: boolean;
     readonly LoggerFactory: ILoggerFactory | undefined;
     readonly LoggingCacheTime: TimeSpan;
-    readonly MaxPoolSize: Nullable<System_Internal.Int32>;
+    readonly MaxPoolSize: Nullable_1<System_Internal.Int32>;
     readonly MemoryCache: IMemoryCache | undefined;
     readonly Model: IModel | undefined;
     readonly QueryTrackingBehavior: QueryTrackingBehavior;
-    readonly ReplacedServices: IReadOnlyDictionary<ValueTuple<Type, Type>, Type | undefined> | undefined;
+    readonly ReplacedServices: IReadOnlyDictionary_2<ValueTuple_2<Type, Type>, Type | undefined> | undefined;
     readonly RootApplicationServiceProvider: IServiceProvider | undefined;
-    readonly Seeder: Action<DbContext, System_Internal.Boolean> | undefined;
+    readonly Seeder: Action_2<DbContext, System_Internal.Boolean> | undefined;
     readonly ServiceProviderCachingEnabled: boolean;
-    readonly SingletonInterceptors: IEnumerable<ISingletonInterceptor> | undefined;
+    readonly SingletonInterceptors: IEnumerable_1<ISingletonInterceptor> | undefined;
     readonly ThreadSafetyChecksEnabled: boolean;
     readonly WarningsConfiguration: WarningsConfiguration;
     ApplyServices(services: IServiceCollection): void;
     Clone(): CoreOptionsExtension;
     Validate(options: IDbContextOptions): void;
     WithApplicationServiceProvider(applicationServiceProvider: IServiceProvider): CoreOptionsExtension;
-    WithAsyncSeeding(seedAsync: Func<DbContext, System_Internal.Boolean, CancellationToken, Task>): CoreOptionsExtension;
+    WithAsyncSeeding(seedAsync: Func_4<DbContext, System_Internal.Boolean, CancellationToken, Task>): CoreOptionsExtension;
     WithDbContextLogger(contextLogger: IDbContextLogger): CoreOptionsExtension;
     WithDetailedErrorsEnabled(detailedErrorsEnabled: boolean): CoreOptionsExtension;
-    WithInterceptors(interceptors: IEnumerable<IInterceptor>): CoreOptionsExtension;
+    WithInterceptors(interceptors: IEnumerable_1<IInterceptor>): CoreOptionsExtension;
     WithInternalServiceProvider(internalServiceProvider: IServiceProvider): CoreOptionsExtension;
     WithLoggerFactory(loggerFactory: ILoggerFactory): CoreOptionsExtension;
     WithLoggingCacheTime(timeSpan: TimeSpan): CoreOptionsExtension;
-    WithMaxPoolSize(maxPoolSize: Nullable<System_Internal.Int32>): CoreOptionsExtension;
+    WithMaxPoolSize(maxPoolSize: Nullable_1<System_Internal.Int32>): CoreOptionsExtension;
     WithMemoryCache(memoryCache: IMemoryCache): CoreOptionsExtension;
     WithModel(model: IModel): CoreOptionsExtension;
     WithQueryTrackingBehavior(queryTrackingBehavior: QueryTrackingBehavior): CoreOptionsExtension;
     WithReplacedService(serviceType: Type, newImplementationType: Type, currentImplementationType?: Type): CoreOptionsExtension;
     WithRootApplicationServiceProvider(rootApplicationServiceProvider: IServiceProvider): CoreOptionsExtension;
     WithRootApplicationServiceProvider(autoResolve?: boolean): CoreOptionsExtension;
-    WithSeeding(seed: Action<DbContext, System_Internal.Boolean>): CoreOptionsExtension;
+    WithSeeding(seed: Action_2<DbContext, System_Internal.Boolean>): CoreOptionsExtension;
     WithSensitiveDataLoggingEnabled(sensitiveDataLoggingEnabled: boolean): CoreOptionsExtension;
     WithServiceProviderCachingEnabled(serviceProviderCachingEnabled: boolean): CoreOptionsExtension;
-    WithSingletonInterceptors(interceptors: IEnumerable<ISingletonInterceptor>): CoreOptionsExtension;
+    WithSingletonInterceptors(interceptors: IEnumerable_1<ISingletonInterceptor>): CoreOptionsExtension;
     WithThreadSafetyChecksEnabled(checksEnabled: boolean): CoreOptionsExtension;
     WithWarningsConfiguration(warningsConfiguration: WarningsConfiguration): CoreOptionsExtension;
 }
@@ -499,28 +579,32 @@ export interface __CoreOptionsExtension$views {
     As_IDbContextOptionsExtension(): IDbContextOptionsExtension$instance;
 }
 
-export interface CoreOptionsExtension$instance extends IDbContextOptionsExtension$instance {}
-
 export type CoreOptionsExtension = CoreOptionsExtension$instance & __CoreOptionsExtension$views;
 
 
 export interface DatabaseFacade$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_DatabaseFacade: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IInfrastructure_1: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IResettableService: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Storage_IDatabaseFacadeDependenciesAccessor: never;
+
     AutoSavepointsEnabled: boolean;
     AutoTransactionBehavior: AutoTransactionBehavior;
     AutoTransactionsEnabled: boolean;
     readonly CurrentTransaction: IDbContextTransaction | undefined;
     readonly ProviderName: string | undefined;
     BeginTransaction(): IDbContextTransaction;
-    BeginTransactionAsync(cancellationToken?: CancellationToken): Task<IDbContextTransaction>;
+    BeginTransactionAsync(cancellationToken?: CancellationToken): Task_1<IDbContextTransaction>;
     CanConnect(): boolean;
-    CanConnectAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    CanConnectAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     CommitTransaction(): void;
     CommitTransactionAsync(cancellationToken?: CancellationToken): Task;
     CreateExecutionStrategy(): IExecutionStrategy;
     EnsureCreated(): boolean;
-    EnsureCreatedAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    EnsureCreatedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     EnsureDeleted(): boolean;
-    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task<System_Internal.Boolean>;
+    EnsureDeletedAsync(cancellationToken?: CancellationToken): Task_1<System_Internal.Boolean>;
     Equals(obj: unknown): boolean;
     GetHashCode(): int;
     RollbackTransaction(): void;
@@ -540,12 +624,12 @@ export interface __DatabaseFacade$views {
     As_IDatabaseFacadeDependenciesAccessor(): Microsoft_EntityFrameworkCore_Storage_Internal.IDatabaseFacadeDependenciesAccessor$instance;
 }
 
-export interface DatabaseFacade$instance extends IInfrastructure_1$instance<IServiceProvider>, IResettableService$instance, Microsoft_EntityFrameworkCore_Storage_Internal.IDatabaseFacadeDependenciesAccessor$instance {}
-
 export type DatabaseFacade = DatabaseFacade$instance & __DatabaseFacade$views;
 
 
 export interface DbContextAttribute$instance extends Attribute {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_DbContextAttribute: never;
+
     readonly ContextType: Type;
 }
 
@@ -558,6 +642,8 @@ export const DbContextAttribute: {
 export type DbContextAttribute = DbContextAttribute$instance;
 
 export interface DbContextModelAttribute$instance extends Attribute {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_DbContextModelAttribute: never;
+
     readonly ContextType: Type;
     readonly ModelType: Type;
 }
@@ -571,11 +657,13 @@ export const DbContextModelAttribute: {
 export type DbContextModelAttribute = DbContextModelAttribute$instance;
 
 export interface DbContextOptionsExtensionInfo$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_DbContextOptionsExtensionInfo: never;
+
     readonly Extension: IDbContextOptionsExtension;
     readonly IsDatabaseProvider: boolean;
     readonly LogFragment: string;
     GetServiceProviderHashCode(): int;
-    PopulateDebugInfo(debugInfo: IDictionary<System_Internal.String, System_Internal.String>): void;
+    PopulateDebugInfo(debugInfo: IDictionary_2<System_Internal.String, System_Internal.String>): void;
     ShouldUseSameServiceProvider(other: DbContextOptionsExtensionInfo): boolean;
 }
 
@@ -587,19 +675,25 @@ export const DbContextOptionsExtensionInfo: (abstract new(extension: IDbContextO
 export type DbContextOptionsExtensionInfo = DbContextOptionsExtensionInfo$instance;
 
 export interface DebugView$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_DebugView: never;
+
     readonly LongView: string;
     readonly ShortView: string;
 }
 
 
 export const DebugView: {
-    new(toShortDebugString: Func<System_Internal.String>, toLongDebugString: Func<System_Internal.String>): DebugView;
+    new(toShortDebugString: Func_1<System_Internal.String>, toLongDebugString: Func_1<System_Internal.String>): DebugView;
 };
 
 
 export type DebugView = DebugView$instance;
 
 export interface EntityFrameworkEventSource$instance extends EventSource {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_EntityFrameworkEventSource: never;
+
+    readonly __tsonic_iface_System_IDisposable: never;
+
     CompiledQueryCacheHit(): void;
     CompiledQueryCacheMiss(): void;
     DbContextDisposing(): void;
@@ -620,6 +714,8 @@ export const EntityFrameworkEventSource: {
 export type EntityFrameworkEventSource = EntityFrameworkEventSource$instance;
 
 export interface EntityFrameworkInternalAttribute$instance extends Attribute {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_EntityFrameworkInternalAttribute: never;
+
 }
 
 
@@ -631,52 +727,58 @@ export const EntityFrameworkInternalAttribute: {
 export type EntityFrameworkInternalAttribute = EntityFrameworkInternalAttribute$instance;
 
 export interface EntityFrameworkRelationalServicesBuilder$instance extends EntityFrameworkServicesBuilder {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_EntityFrameworkRelationalServicesBuilder: never;
+
     TryAddCoreServices(): EntityFrameworkServicesBuilder;
-    TryGetServiceCharacteristics(serviceType: Type): Nullable<ServiceCharacteristics>;
-    TryGetServiceCharacteristics(serviceType: Type): Nullable<ServiceCharacteristics>;
+    TryGetServiceCharacteristics(serviceType: Type): Nullable_1<ServiceCharacteristics>;
+    TryGetServiceCharacteristics(serviceType: Type): Nullable_1<ServiceCharacteristics>;
 }
 
 
 export const EntityFrameworkRelationalServicesBuilder: {
     new(serviceCollection: IServiceCollection): EntityFrameworkRelationalServicesBuilder;
-    readonly RelationalServices: IDictionary<Type, ServiceCharacteristics>;
+    readonly RelationalServices: IDictionary_2<Type, ServiceCharacteristics>;
 };
 
 
 export type EntityFrameworkRelationalServicesBuilder = EntityFrameworkRelationalServicesBuilder$instance;
 
 export interface EntityFrameworkServicesBuilder$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_EntityFrameworkServicesBuilder: never;
+
     readonly ServiceCollectionMap: ServiceCollectionMap;
     GetServiceCharacteristics(serviceType: Type): ServiceCharacteristics;
     TryAdd<TService, TImplementation extends TService>(): EntityFrameworkServicesBuilder;
     TryAdd(serviceType: Type, implementationType: Type): EntityFrameworkServicesBuilder;
-    TryAdd<TService>(factory: Func<IServiceProvider, TService>): EntityFrameworkServicesBuilder;
-    TryAdd(serviceType: Type, implementationType: Type, factory: Func<IServiceProvider, unknown>): EntityFrameworkServicesBuilder;
+    TryAdd<TService>(factory: Func_2<IServiceProvider, TService>): EntityFrameworkServicesBuilder;
+    TryAdd(serviceType: Type, implementationType: Type, factory: Func_2<IServiceProvider, unknown>): EntityFrameworkServicesBuilder;
     TryAdd<TService>(implementation: TService): EntityFrameworkServicesBuilder;
     TryAdd(serviceType: Type, implementation: unknown): EntityFrameworkServicesBuilder;
     TryAddCoreServices(): EntityFrameworkServicesBuilder;
-    TryAddProviderSpecificServices(serviceMap: Action<ServiceCollectionMap>): EntityFrameworkServicesBuilder;
-    TryGetServiceCharacteristics(serviceType: Type): Nullable<ServiceCharacteristics>;
+    TryAddProviderSpecificServices(serviceMap: Action_1<ServiceCollectionMap>): EntityFrameworkServicesBuilder;
+    TryGetServiceCharacteristics(serviceType: Type): Nullable_1<ServiceCharacteristics>;
 }
 
 
 export const EntityFrameworkServicesBuilder: {
     new(serviceCollection: IServiceCollection): EntityFrameworkServicesBuilder;
-    readonly CoreServices: IDictionary<Type, ServiceCharacteristics>;
+    readonly CoreServices: IDictionary_2<Type, ServiceCharacteristics>;
 };
 
 
 export type EntityFrameworkServicesBuilder = EntityFrameworkServicesBuilder$instance;
 
 export interface IndentedStringBuilder$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_IndentedStringBuilder: never;
+
     readonly IndentCount: int;
     readonly Length: int;
     Append(value: string): IndentedStringBuilder;
     Append(value: FormattableString): IndentedStringBuilder;
     Append(value: char): IndentedStringBuilder;
-    Append(value: IEnumerable<System_Internal.String>): IndentedStringBuilder;
-    Append(value: IEnumerable<System_Internal.Char>): IndentedStringBuilder;
-    AppendJoin(values: IEnumerable<System_Internal.String>, separator?: string): IndentedStringBuilder;
+    Append(value: IEnumerable_1<System_Internal.String>): IndentedStringBuilder;
+    Append(value: IEnumerable_1<System_Internal.Char>): IndentedStringBuilder;
+    AppendJoin(values: IEnumerable_1<System_Internal.String>, separator?: string): IndentedStringBuilder;
     AppendJoin(separator: string, ...values: string[]): IndentedStringBuilder;
     AppendLine(): IndentedStringBuilder;
     AppendLine(value: string): IndentedStringBuilder;
@@ -700,6 +802,8 @@ export const IndentedStringBuilder: {
 export type IndentedStringBuilder = IndentedStringBuilder$instance;
 
 export interface ModelCacheKey$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelCacheKey: never;
+
     Equals(other: ModelCacheKey): boolean;
     Equals(obj: unknown): boolean;
     GetHashCode(): int;
@@ -715,6 +819,10 @@ export const ModelCacheKey: {
 export type ModelCacheKey = ModelCacheKey$instance;
 
 export interface ModelCacheKeyFactory$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelCacheKeyFactory: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelCacheKeyFactory: never;
+
     readonly Dependencies: ModelCacheKeyFactoryDependencies;
     Create(context: DbContext): unknown;
     Create(context: DbContext, designTime: boolean): unknown;
@@ -734,6 +842,10 @@ export type ModelCacheKeyFactory = ModelCacheKeyFactory$instance & __ModelCacheK
 
 
 export interface ModelCacheKeyFactoryDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelCacheKeyFactoryDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     _Clone_$(): ModelCacheKeyFactoryDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: ModelCacheKeyFactoryDependencies): boolean;
@@ -749,7 +861,11 @@ export const ModelCacheKeyFactoryDependencies: {
 
 export type ModelCacheKeyFactoryDependencies = ModelCacheKeyFactoryDependencies$instance;
 
-export interface ModelCustomizer$instance {
+export interface ModelCustomizer$instance extends IModelCustomizer$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelCustomizer: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelCustomizer: never;
+
     readonly Dependencies: ModelCustomizerDependencies;
     Customize(modelBuilder: ModelBuilder, context: DbContext): void;
 }
@@ -764,12 +880,14 @@ export interface __ModelCustomizer$views {
     As_IModelCustomizer(): IModelCustomizer$instance;
 }
 
-export interface ModelCustomizer$instance extends IModelCustomizer$instance {}
-
 export type ModelCustomizer = ModelCustomizer$instance & __ModelCustomizer$views;
 
 
 export interface ModelCustomizerDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelCustomizerDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     _Clone_$(): ModelCustomizerDependencies;
     Equals(obj: unknown): boolean;
     Equals(other: ModelCustomizerDependencies): boolean;
@@ -786,6 +904,10 @@ export const ModelCustomizerDependencies: {
 export type ModelCustomizerDependencies = ModelCustomizerDependencies$instance;
 
 export interface ModelDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     Logger: IDiagnosticsLogger_1<DbLoggerCategory_Model>;
     _Clone_$(): ModelDependencies;
     Equals(obj: unknown): boolean;
@@ -803,6 +925,8 @@ export const ModelDependencies: {
 export type ModelDependencies = ModelDependencies$instance;
 
 export interface ModelRuntimeInitializer$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelRuntimeInitializer: never;
+
     readonly Dependencies: ModelRuntimeInitializerDependencies;
     Initialize(model: IModel, designTime?: boolean, validationLogger?: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): IModel;
     InitializeModel(model: IModel, designTime: boolean, prevalidation: boolean): void;
@@ -817,6 +941,10 @@ export const ModelRuntimeInitializer: {
 export type ModelRuntimeInitializer = ModelRuntimeInitializer$instance;
 
 export interface ModelRuntimeInitializerDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelRuntimeInitializerDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     ModelDependencies: RuntimeModelDependencies;
     ModelValidator: IModelValidator;
     _Clone_$(): ModelRuntimeInitializerDependencies;
@@ -835,6 +963,8 @@ export const ModelRuntimeInitializerDependencies: {
 export type ModelRuntimeInitializerDependencies = ModelRuntimeInitializerDependencies$instance;
 
 export interface ModelSnapshot$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelSnapshot: never;
+
     readonly Model: IModel;
     BuildModel(modelBuilder: ModelBuilder): void;
 }
@@ -846,7 +976,11 @@ export const ModelSnapshot: (abstract new() => ModelSnapshot) & {
 
 export type ModelSnapshot = ModelSnapshot$instance;
 
-export interface ModelSource$instance {
+export interface ModelSource$instance extends IModelSource$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelSource: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelSource: never;
+
     readonly Dependencies: ModelSourceDependencies;
     CreateModel(context: DbContext, modelCreationDependencies: ModelCreationDependencies, designTime: boolean): IModel;
     CreateModel(context: DbContext, conventionSetBuilder: IConventionSetBuilder, modelDependencies: ModelDependencies): IModel;
@@ -863,12 +997,14 @@ export interface __ModelSource$views {
     As_IModelSource(): IModelSource$instance;
 }
 
-export interface ModelSource$instance extends IModelSource$instance {}
-
 export type ModelSource = ModelSource$instance & __ModelSource$views;
 
 
 export interface ModelSourceDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelSourceDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     MemoryCache: IMemoryCache;
     ModelCacheKeyFactory: IModelCacheKeyFactory;
     ModelCustomizer: IModelCustomizer;
@@ -887,7 +1023,11 @@ export const ModelSourceDependencies: {
 
 export type ModelSourceDependencies = ModelSourceDependencies$instance;
 
-export interface ModelValidator$instance {
+export interface ModelValidator$instance extends IModelValidator$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelValidator: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelValidator: never;
+
     readonly Dependencies: ModelValidatorDependencies;
     IsOwned(targetType: Type, conventionModel: IConventionModel): boolean;
     IsRedundant(foreignKey: IForeignKey): boolean;
@@ -929,12 +1069,14 @@ export interface __ModelValidator$views {
     As_IModelValidator(): IModelValidator$instance;
 }
 
-export interface ModelValidator$instance extends IModelValidator$instance {}
-
 export type ModelValidator = ModelValidator$instance & __ModelValidator$views;
 
 
 export interface ModelValidatorDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ModelValidatorDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     MemberClassifier: IMemberClassifier;
     _Clone_$(): ModelValidatorDependencies;
     Equals(obj: unknown): boolean;
@@ -951,9 +1093,13 @@ export const ModelValidatorDependencies: {
 
 export type ModelValidatorDependencies = ModelValidatorDependencies$instance;
 
-export interface PooledDbContextFactory_1$instance<TContext extends DbContext> {
+export interface PooledDbContextFactory_1$instance<TContext extends DbContext> extends Microsoft_EntityFrameworkCore_Internal.IDbContextFactory_1$instance<TContext> {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_PooledDbContextFactory_1: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_IDbContextFactory_1: never;
+
     CreateDbContext(): TContext;
-    CreateDbContextAsync(cancellationToken?: CancellationToken): Task<TContext>;
+    CreateDbContextAsync(cancellationToken?: CancellationToken): Task_1<TContext>;
 }
 
 
@@ -967,16 +1113,18 @@ export interface __PooledDbContextFactory_1$views<TContext extends DbContext> {
     As_IDbContextFactory_1(): Microsoft_EntityFrameworkCore_Internal.IDbContextFactory_1$instance<TContext>;
 }
 
-export interface PooledDbContextFactory_1$instance<TContext extends DbContext> extends Microsoft_EntityFrameworkCore_Internal.IDbContextFactory_1$instance<TContext> {}
-
 export type PooledDbContextFactory_1<TContext extends DbContext> = PooledDbContextFactory_1$instance<TContext> & __PooledDbContextFactory_1$views<TContext>;
 
 
-export interface RelationalDbContextOptionsBuilder_2$instance<TBuilder extends RelationalDbContextOptionsBuilder_2<TBuilder, TExtension>, TExtension extends RelationalOptionsExtension> {
+export interface RelationalDbContextOptionsBuilder_2$instance<TBuilder extends RelationalDbContextOptionsBuilder_2<TBuilder, TExtension>, TExtension extends RelationalOptionsExtension> extends IRelationalDbContextOptionsBuilderInfrastructure$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RelationalDbContextOptionsBuilder_2: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IRelationalDbContextOptionsBuilderInfrastructure: never;
+
     readonly OptionsBuilder: DbContextOptionsBuilder;
-    CommandTimeout(commandTimeout: Nullable<System_Internal.Int32>): TBuilder;
+    CommandTimeout(commandTimeout: Nullable_1<System_Internal.Int32>): TBuilder;
     Equals(obj: unknown): boolean;
-    ExecutionStrategy(getExecutionStrategy: Func<ExecutionStrategyDependencies, IExecutionStrategy>): TBuilder;
+    ExecutionStrategy(getExecutionStrategy: Func_2<ExecutionStrategyDependencies, IExecutionStrategy>): TBuilder;
     GetHashCode(): int;
     MaxBatchSize(maxBatchSize: int): TBuilder;
     MigrationsAssembly(assemblyName: string): TBuilder;
@@ -989,7 +1137,7 @@ export interface RelationalDbContextOptionsBuilder_2$instance<TBuilder extends R
     UseParameterizedCollectionMode(parameterizedCollectionMode: ParameterTranslationMode): TBuilder;
     UseQuerySplittingBehavior(querySplittingBehavior: QuerySplittingBehavior): TBuilder;
     UseRelationalNulls(useRelationalNulls?: boolean): TBuilder;
-    WithOption(setAction: Func<TExtension, TExtension>): TBuilder;
+    WithOption(setAction: Func_2<TExtension, TExtension>): TBuilder;
 }
 
 
@@ -1001,12 +1149,14 @@ export interface __RelationalDbContextOptionsBuilder_2$views<TBuilder extends Re
     As_IRelationalDbContextOptionsBuilderInfrastructure(): IRelationalDbContextOptionsBuilderInfrastructure$instance;
 }
 
-export interface RelationalDbContextOptionsBuilder_2$instance<TBuilder extends RelationalDbContextOptionsBuilder_2<TBuilder, TExtension>, TExtension extends RelationalOptionsExtension> extends IRelationalDbContextOptionsBuilderInfrastructure$instance {}
-
 export type RelationalDbContextOptionsBuilder_2<TBuilder extends RelationalDbContextOptionsBuilder_2<TBuilder, TExtension>, TExtension extends RelationalOptionsExtension> = RelationalDbContextOptionsBuilder_2$instance<TBuilder, TExtension> & __RelationalDbContextOptionsBuilder_2$views<TBuilder, TExtension>;
 
 
 export interface RelationalModelCustomizer$instance extends ModelCustomizer$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RelationalModelCustomizer: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelCustomizer: never;
+
     Customize(modelBuilder: ModelBuilder, context: DbContext): void;
 }
 
@@ -1024,6 +1174,10 @@ export type RelationalModelCustomizer = RelationalModelCustomizer$instance & __R
 
 
 export interface RelationalModelDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RelationalModelDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     RowForeignKeyValueFactoryFactory: IRowForeignKeyValueFactoryFactory;
     RowIndexValueFactoryFactory: IRowIndexValueFactoryFactory;
     RowKeyValueFactoryFactory: IRowKeyValueFactoryFactory;
@@ -1044,6 +1198,10 @@ export const RelationalModelDependencies: {
 export type RelationalModelDependencies = RelationalModelDependencies$instance;
 
 export interface RelationalModelRuntimeInitializer$instance extends ModelRuntimeInitializer {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RelationalModelRuntimeInitializer: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelRuntimeInitializer: never;
+
     readonly RelationalDependencies: RelationalModelRuntimeInitializerDependencies;
     Initialize(model: IModel, designTime?: boolean, validationLogger?: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): IModel;
     InitializeModel(model: IModel, designTime: boolean, prevalidation: boolean): void;
@@ -1063,6 +1221,10 @@ export type RelationalModelRuntimeInitializer = RelationalModelRuntimeInitialize
 
 
 export interface RelationalModelRuntimeInitializerDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RelationalModelRuntimeInitializerDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     RelationalAnnotationProvider: IRelationalAnnotationProvider;
     RelationalModelDependencies: RelationalModelDependencies;
     _Clone_$(): RelationalModelRuntimeInitializerDependencies;
@@ -1081,6 +1243,10 @@ export const RelationalModelRuntimeInitializerDependencies: {
 export type RelationalModelRuntimeInitializerDependencies = RelationalModelRuntimeInitializerDependencies$instance;
 
 export interface RelationalModelValidator$instance extends ModelValidator$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RelationalModelValidator: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IModelValidator: never;
+
     readonly RelationalDependencies: RelationalModelValidatorDependencies;
     GetDefaultColumnValue(property: IProperty, storeObject: StoreObjectIdentifier): unknown | undefined;
     IsRedundant(foreignKey: IForeignKey): boolean;
@@ -1117,16 +1283,16 @@ export interface RelationalModelValidator$instance extends ModelValidator$instan
     ValidatePropertyMapping(structuralType: IConventionTypeBase, model: IConventionModel, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
     ValidatePropertyMapping(complexProperty: IConventionComplexProperty, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
     ValidatePropertyOverrides(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
-    ValidateSharedCheckConstraintCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
-    ValidateSharedColumnsCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
-    ValidateSharedForeignKeysCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
-    ValidateSharedIndexesCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
-    ValidateSharedKeysCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
+    ValidateSharedCheckConstraintCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
+    ValidateSharedColumnsCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
+    ValidateSharedForeignKeysCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
+    ValidateSharedIndexesCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
+    ValidateSharedKeysCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
     ValidateSharedTableCompatibility(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
-    ValidateSharedTableCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
-    ValidateSharedTriggerCompatibility(mappedTypes: IReadOnlyList<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
+    ValidateSharedTableCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
+    ValidateSharedTriggerCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, storeObject: StoreObjectIdentifier, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
     ValidateSharedViewCompatibility(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
-    ValidateSharedViewCompatibility(mappedTypes: IReadOnlyList<IEntityType>, viewName: string, schema: string, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
+    ValidateSharedViewCompatibility(mappedTypes: IReadOnlyList_1<IEntityType>, viewName: string, schema: string, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
     ValidateSqlQueries(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
     ValidateStoredProcedures(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
     ValidateTriggers(model: IModel, logger: IDiagnosticsLogger_1<DbLoggerCategory_Model_Validation>): void;
@@ -1148,6 +1314,10 @@ export type RelationalModelValidator = RelationalModelValidator$instance & __Rel
 
 
 export interface RelationalModelValidatorDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RelationalModelValidatorDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     TypeMappingSource: IRelationalTypeMappingSource;
     _Clone_$(): RelationalModelValidatorDependencies;
     Equals(obj: unknown): boolean;
@@ -1164,36 +1334,40 @@ export const RelationalModelValidatorDependencies: {
 
 export type RelationalModelValidatorDependencies = RelationalModelValidatorDependencies$instance;
 
-export interface RelationalOptionsExtension$instance {
-    readonly CommandTimeout: Nullable<System_Internal.Int32>;
+export interface RelationalOptionsExtension$instance extends IDbContextOptionsExtension$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RelationalOptionsExtension: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IDbContextOptionsExtension: never;
+
+    readonly CommandTimeout: Nullable_1<System_Internal.Int32>;
     readonly Connection: DbConnection | undefined;
     readonly ConnectionString: string | undefined;
-    readonly ExecutionStrategyFactory: Func<ExecutionStrategyDependencies, IExecutionStrategy> | undefined;
+    readonly ExecutionStrategyFactory: Func_2<ExecutionStrategyDependencies, IExecutionStrategy> | undefined;
     readonly Info: DbContextOptionsExtensionInfo;
     readonly IsConnectionOwned: boolean;
-    readonly MaxBatchSize: Nullable<System_Internal.Int32>;
+    readonly MaxBatchSize: Nullable_1<System_Internal.Int32>;
     readonly MigrationsAssembly: string | undefined;
     readonly MigrationsAssemblyObject: Assembly | undefined;
     readonly MigrationsHistoryTableName: string | undefined;
     readonly MigrationsHistoryTableSchema: string | undefined;
-    readonly MinBatchSize: Nullable<System_Internal.Int32>;
+    readonly MinBatchSize: Nullable_1<System_Internal.Int32>;
     readonly ParameterizedCollectionMode: ParameterTranslationMode;
-    readonly QuerySplittingBehavior: Nullable<QuerySplittingBehavior>;
+    readonly QuerySplittingBehavior: Nullable_1<QuerySplittingBehavior>;
     readonly UseRelationalNulls: boolean;
     ApplyServices(services: IServiceCollection): void;
     Clone(): RelationalOptionsExtension;
     Validate(options: IDbContextOptions): void;
-    WithCommandTimeout(commandTimeout: Nullable<System_Internal.Int32>): RelationalOptionsExtension;
+    WithCommandTimeout(commandTimeout: Nullable_1<System_Internal.Int32>): RelationalOptionsExtension;
     WithConnection(connection: DbConnection): RelationalOptionsExtension;
     WithConnection(connection: DbConnection, owned: boolean): RelationalOptionsExtension;
     WithConnectionString(connectionString: string): RelationalOptionsExtension;
-    WithExecutionStrategyFactory(executionStrategyFactory: Func<ExecutionStrategyDependencies, IExecutionStrategy>): RelationalOptionsExtension;
-    WithMaxBatchSize(maxBatchSize: Nullable<System_Internal.Int32>): RelationalOptionsExtension;
+    WithExecutionStrategyFactory(executionStrategyFactory: Func_2<ExecutionStrategyDependencies, IExecutionStrategy>): RelationalOptionsExtension;
+    WithMaxBatchSize(maxBatchSize: Nullable_1<System_Internal.Int32>): RelationalOptionsExtension;
     WithMigrationsAssembly(migrationsAssembly: string): RelationalOptionsExtension;
     WithMigrationsAssembly(migrationsAssembly: Assembly): RelationalOptionsExtension;
     WithMigrationsHistoryTableName(migrationsHistoryTableName: string): RelationalOptionsExtension;
     WithMigrationsHistoryTableSchema(migrationsHistoryTableSchema: string): RelationalOptionsExtension;
-    WithMinBatchSize(minBatchSize: Nullable<System_Internal.Int32>): RelationalOptionsExtension;
+    WithMinBatchSize(minBatchSize: Nullable_1<System_Internal.Int32>): RelationalOptionsExtension;
     WithUseParameterizedCollectionMode(parameterizedCollectionMode: ParameterTranslationMode): RelationalOptionsExtension;
     WithUseQuerySplittingBehavior(querySplittingBehavior: QuerySplittingBehavior): RelationalOptionsExtension;
     WithUseRelationalNulls(useRelationalNulls: boolean): RelationalOptionsExtension;
@@ -1210,27 +1384,30 @@ export interface __RelationalOptionsExtension$views {
     As_IDbContextOptionsExtension(): IDbContextOptionsExtension$instance;
 }
 
-export interface RelationalOptionsExtension$instance extends IDbContextOptionsExtension$instance {}
-
 export type RelationalOptionsExtension = RelationalOptionsExtension$instance & __RelationalOptionsExtension$views;
 
 
 export interface RuntimeAnnotatableBase$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RuntimeAnnotatableBase: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IAnnotatable: never;
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IReadOnlyAnnotatable: never;
+
     [name: string]: unknown | undefined;
     AddAnnotation(name: string, value: unknown): Annotation;
-    AddAnnotations(annotations: IEnumerable<IAnnotation>): void;
-    AddAnnotations(annotations: IReadOnlyDictionary<System_Internal.String, unknown>): void;
+    AddAnnotations(annotations: IEnumerable_1<IAnnotation>): void;
+    AddAnnotations(annotations: IReadOnlyDictionary_2<System_Internal.String, unknown>): void;
     AddRuntimeAnnotation(name: string, value: unknown): Annotation;
     AddRuntimeAnnotation(name: string, annotation: Annotation): Annotation;
-    AddRuntimeAnnotations(annotations: IEnumerable<Annotation>): void;
-    AddRuntimeAnnotations(annotations: IReadOnlyDictionary<System_Internal.String, unknown>): void;
+    AddRuntimeAnnotations(annotations: IEnumerable_1<Annotation>): void;
+    AddRuntimeAnnotations(annotations: IReadOnlyDictionary_2<System_Internal.String, unknown>): void;
     CreateAnnotation(name: string, value: unknown): Annotation;
     CreateRuntimeAnnotation(name: string, value: unknown): Annotation;
     FindAnnotation(name: string): Annotation | undefined;
     FindRuntimeAnnotation(name: string): Annotation | undefined;
     GetAnnotation(annotationName: string): Annotation;
-    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func<TArg, TValue>, factoryArgument: TArg): TValue;
-    GetRuntimeAnnotations(): IEnumerable<Annotation>;
+    GetOrAddRuntimeAnnotationValue<TValue, TArg>(name: string, valueFactory: Func_2<TArg, TValue>, factoryArgument: TArg): TValue;
+    GetRuntimeAnnotations(): IEnumerable_1<Annotation>;
     RemoveAnnotation(name: string): Annotation | undefined;
     RemoveRuntimeAnnotation(name: string): Annotation | undefined;
     SetAnnotation(name: string, value: unknown): void;
@@ -1253,6 +1430,10 @@ export type RuntimeAnnotatableBase = RuntimeAnnotatableBase$instance & __Runtime
 
 
 export interface RuntimeModelDependencies$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_RuntimeModelDependencies: never;
+
+    readonly __tsonic_iface_System_IEquatable_1: never;
+
     ConstructorBindingFactory: IConstructorBindingFactory;
     ParameterBindingFactories: IParameterBindingFactories;
     TypeMappingSource: ITypeMappingSource;
@@ -1272,36 +1453,40 @@ export const RuntimeModelDependencies: {
 export type RuntimeModelDependencies = RuntimeModelDependencies$instance;
 
 export interface ServiceCollectionMap$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ServiceCollectionMap: never;
+
+    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Infrastructure_IInfrastructure_1: never;
+
     readonly ServiceCollection: IServiceCollection;
     TryAdd(serviceType: Type, implementationType: Type, lifetime: ServiceLifetime): ServiceCollectionMap;
-    TryAdd(serviceType: Type, factory: Func<IServiceProvider, unknown>, lifetime: ServiceLifetime): ServiceCollectionMap;
+    TryAdd(serviceType: Type, factory: Func_2<IServiceProvider, unknown>, lifetime: ServiceLifetime): ServiceCollectionMap;
     TryAddEnumerable(serviceType: Type, implementationType: Type, lifetime: ServiceLifetime): ServiceCollectionMap;
-    TryAddEnumerable(serviceType: Type, implementationType: Type, factory: Func<IServiceProvider, unknown>, lifetime: ServiceLifetime): ServiceCollectionMap;
+    TryAddEnumerable(serviceType: Type, implementationType: Type, factory: Func_2<IServiceProvider, unknown>, lifetime: ServiceLifetime): ServiceCollectionMap;
     TryAddScoped<TService, TImplementation extends TService>(): ServiceCollectionMap;
     TryAddScoped(serviceType: Type, implementationType: Type): ServiceCollectionMap;
-    TryAddScoped<TService>(factory: Func<IServiceProvider, TService>): ServiceCollectionMap;
-    TryAddScoped(serviceType: Type, factory: Func<IServiceProvider, unknown>): ServiceCollectionMap;
+    TryAddScoped<TService>(factory: Func_2<IServiceProvider, TService>): ServiceCollectionMap;
+    TryAddScoped(serviceType: Type, factory: Func_2<IServiceProvider, unknown>): ServiceCollectionMap;
     TryAddScopedEnumerable<TService, TImplementation extends TService>(): ServiceCollectionMap;
     TryAddScopedEnumerable(serviceType: Type, implementationType: Type): ServiceCollectionMap;
-    TryAddScopedEnumerable<TService, TImplementation extends TService>(factory: Func<IServiceProvider, TImplementation>): ServiceCollectionMap;
+    TryAddScopedEnumerable<TService, TImplementation extends TService>(factory: Func_2<IServiceProvider, TImplementation>): ServiceCollectionMap;
     TryAddSingleton<TService, TImplementation extends TService>(): ServiceCollectionMap;
     TryAddSingleton(serviceType: Type, implementationType: Type): ServiceCollectionMap;
-    TryAddSingleton<TService>(factory: Func<IServiceProvider, TService>): ServiceCollectionMap;
-    TryAddSingleton(serviceType: Type, factory: Func<IServiceProvider, unknown>): ServiceCollectionMap;
+    TryAddSingleton<TService>(factory: Func_2<IServiceProvider, TService>): ServiceCollectionMap;
+    TryAddSingleton(serviceType: Type, factory: Func_2<IServiceProvider, unknown>): ServiceCollectionMap;
     TryAddSingleton<TService>(implementation: TService): ServiceCollectionMap;
     TryAddSingleton(serviceType: Type, implementation: unknown): ServiceCollectionMap;
     TryAddSingletonEnumerable<TService, TImplementation extends TService>(): ServiceCollectionMap;
     TryAddSingletonEnumerable(serviceType: Type, implementationType: Type): ServiceCollectionMap;
-    TryAddSingletonEnumerable<TService, TImplementation extends TService>(factory: Func<IServiceProvider, TImplementation>): ServiceCollectionMap;
+    TryAddSingletonEnumerable<TService, TImplementation extends TService>(factory: Func_2<IServiceProvider, TImplementation>): ServiceCollectionMap;
     TryAddSingletonEnumerable<TService>(implementation: TService): ServiceCollectionMap;
     TryAddSingletonEnumerable(serviceType: Type, implementation: unknown): ServiceCollectionMap;
     TryAddTransient<TService, TImplementation extends TService>(): ServiceCollectionMap;
     TryAddTransient(serviceType: Type, implementationType: Type): ServiceCollectionMap;
-    TryAddTransient<TService>(factory: Func<IServiceProvider, TService>): ServiceCollectionMap;
-    TryAddTransient(serviceType: Type, factory: Func<IServiceProvider, unknown>): ServiceCollectionMap;
+    TryAddTransient<TService>(factory: Func_2<IServiceProvider, TService>): ServiceCollectionMap;
+    TryAddTransient(serviceType: Type, factory: Func_2<IServiceProvider, unknown>): ServiceCollectionMap;
     TryAddTransientEnumerable<TService, TImplementation extends TService>(): ServiceCollectionMap;
     TryAddTransientEnumerable(serviceType: Type, implementationType: Type): ServiceCollectionMap;
-    TryAddTransientEnumerable<TService, TImplementation extends TService>(factory: Func<IServiceProvider, TImplementation>): ServiceCollectionMap;
+    TryAddTransientEnumerable<TService, TImplementation extends TService>(factory: Func_2<IServiceProvider, TImplementation>): ServiceCollectionMap;
 }
 
 
@@ -1314,12 +1499,12 @@ export interface __ServiceCollectionMap$views {
     As_IInfrastructure_1(): IInfrastructure_1$instance<IInternalServiceCollectionMap>;
 }
 
-export interface ServiceCollectionMap$instance extends IInfrastructure_1$instance<IInternalServiceCollectionMap> {}
-
 export type ServiceCollectionMap = ServiceCollectionMap$instance & __ServiceCollectionMap$views;
 
 
 export interface ServiceProviderAccessor$instance {
+    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Infrastructure_ServiceProviderAccessor: never;
+
     readonly RootServiceProvider: IServiceProvider;
 }
 
@@ -1360,16 +1545,16 @@ export abstract class ExpressionExtensions$instance {
     static CreateEFPropertyExpression(target: Expression, property: IPropertyBase, makeNullable?: boolean): Expression;
     static CreateEFPropertyExpression(target: Expression, propertyDeclaringType: Type, propertyType: Type, propertyName: string, makeNullable: boolean): Expression;
     static CreateEqualsExpression(left: Expression, right: Expression, negated?: boolean): Expression;
-    static CreateKeyValuesExpression(target: Expression, properties: IReadOnlyList<IProperty>, makeNullable?: boolean): Expression;
+    static CreateKeyValuesExpression(target: Expression, properties: IReadOnlyList_1<IProperty>, makeNullable?: boolean): Expression;
     static CreateValueBufferReadValueExpression(valueBuffer: Expression, type: Type, index: int, property: IPropertyBase): Expression;
     static GetMemberAccess(memberAccessExpression: LambdaExpression): MemberInfo;
-    static GetMemberAccessList(memberAccessExpression: LambdaExpression): IReadOnlyList<MemberInfo>;
+    static GetMemberAccessList(memberAccessExpression: LambdaExpression): IReadOnlyList_1<MemberInfo>;
     static GetPropertyAccess(propertyAccessExpression: LambdaExpression): PropertyInfo;
-    static GetPropertyAccessList(propertyAccessExpression: LambdaExpression): IReadOnlyList<PropertyInfo>;
+    static GetPropertyAccessList(propertyAccessExpression: LambdaExpression): IReadOnlyList_1<PropertyInfo>;
     static IsMemberAccess(expression: Expression, model: IModel, baseExpression: Expression, memberIdentity: MemberIdentity): boolean;
     static IsMemberAccess(expression: Expression, model: IModel, baseExpression: Expression): boolean;
     static MakeMemberAccess(expression: Expression, member: MemberInfo): MemberExpression;
-    static Print(expression: Expression, characterLimit?: Nullable<System_Internal.Int32>): string;
+    static Print(expression: Expression, characterLimit?: Nullable_1<System_Internal.Int32>): string;
     static TryGetEFPropertyArguments(methodCallExpression: MethodCallExpression, entityExpression: Expression, propertyName: string): boolean;
     static TryGetIndexerArguments(methodCallExpression: MethodCallExpression, model: IModel, entityExpression: Expression, propertyName: string): boolean;
 }
@@ -1406,8 +1591,8 @@ export abstract class RelationalModelExtensions$instance {
 export type RelationalModelExtensions = RelationalModelExtensions$instance;
 
 export abstract class RelationalPropertyExtensions$instance {
-    static FormatColumns(properties: IEnumerable<IReadOnlyProperty>, storeObject: StoreObjectIdentifier): string;
-    static GetColumnNames(properties: IEnumerable<IReadOnlyProperty>, storeObject: StoreObjectIdentifier): IReadOnlyList<System_Internal.String> | undefined;
+    static FormatColumns(properties: IEnumerable_1<IReadOnlyProperty>, storeObject: StoreObjectIdentifier): string;
+    static GetColumnNames(properties: IEnumerable_1<IReadOnlyProperty>, storeObject: StoreObjectIdentifier): IReadOnlyList_1<System_Internal.String> | undefined;
 }
 
 
@@ -1421,13 +1606,13 @@ export abstract class TypeExtensions$instance {
 export type TypeExtensions = TypeExtensions$instance;
 
 export abstract class Uniquifier$instance {
-    static Truncate(identifier: string, maxLength: int, uniquifier?: Nullable<System_Internal.Int32>): string;
-    static Truncate(identifier: string, maxLength: int, suffix: string, uniquifier?: Nullable<System_Internal.Int32>): string;
-    static Uniquify<TKey, TValue>(currentIdentifier: string, otherIdentifiers: IReadOnlyDictionary<TKey, TValue>, keySelector: Func<System_Internal.String, TKey>, maxLength: int): string;
-    static Uniquify<TKey, TValue>(currentIdentifier: string, otherIdentifiers: IReadOnlyDictionary<TKey, TValue>, keySelector: Func<System_Internal.String, TKey>, suffix: string, maxLength: int): string;
-    static Uniquify<T>(currentIdentifier: string, otherIdentifiers: IReadOnlyDictionary<System_Internal.String, T>, maxLength: int): string;
-    static Uniquify<T>(currentIdentifier: string, otherIdentifiers: IReadOnlyDictionary<System_Internal.String, T>, suffix: string, maxLength: int): string;
-    static Uniquify(currentIdentifier: string, otherIdentifiers: ISet<System_Internal.String>, suffix: string, maxLength: int): string;
+    static Truncate(identifier: string, maxLength: int, uniquifier?: Nullable_1<System_Internal.Int32>): string;
+    static Truncate(identifier: string, maxLength: int, suffix: string, uniquifier?: Nullable_1<System_Internal.Int32>): string;
+    static Uniquify<TKey, TValue>(currentIdentifier: string, otherIdentifiers: IReadOnlyDictionary_2<TKey, TValue>, keySelector: Func_2<System_Internal.String, TKey>, maxLength: int): string;
+    static Uniquify<TKey, TValue>(currentIdentifier: string, otherIdentifiers: IReadOnlyDictionary_2<TKey, TValue>, keySelector: Func_2<System_Internal.String, TKey>, suffix: string, maxLength: int): string;
+    static Uniquify<T>(currentIdentifier: string, otherIdentifiers: IReadOnlyDictionary_2<System_Internal.String, T>, maxLength: int): string;
+    static Uniquify<T>(currentIdentifier: string, otherIdentifiers: IReadOnlyDictionary_2<System_Internal.String, T>, suffix: string, maxLength: int): string;
+    static Uniquify(currentIdentifier: string, otherIdentifiers: ISet_1<System_Internal.String>, suffix: string, maxLength: int): string;
 }