// Generated by tsbindgen - Architecture
// Namespace: Microsoft.EntityFrameworkCore.Query
// Assembly: Microsoft.EntityFrameworkCore, Microsoft.EntityFrameworkCore.Abstractions, 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 { InternalEntityEntry, ISnapshot, IStateManager } from "../../Microsoft.EntityFrameworkCore.ChangeTracking.Internal/internal/index.js";
import type { ValueComparer } from "../../Microsoft.EntityFrameworkCore.ChangeTracking/internal/index.js";
import type { CommandSource, IDiagnosticsLogger_1, IInterceptors, IRelationalCommandDiagnosticsLogger, ISingletonInterceptor } from "../../Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
import type { IAnnotation, IConcurrencyDetector, ICoreSingletonOptions, ICurrentDbContext, IDbContextOptions } from "../../Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
import type { IDbContextServices } from "../../Microsoft.EntityFrameworkCore.Internal/internal/index.js";
import type { IClrCollectionAccessor, IComplexProperty, IComplexType, IEntityType, IKey, IModel, INavigation, INavigationBase, IProperty, IPropertyBase, ITableBase, ITypeBase, MemberIdentity } from "../../Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
import type { RelationalCommandResolver, ResultContext, SingleQueryResultCoordinator, SplitQueryResultCoordinator } from "../../Microsoft.EntityFrameworkCore.Query.Internal/internal/index.js";
import type { AtTimeZoneExpression, CaseExpression, CaseWhenClause, CollateExpression, ColumnExpression, ColumnValueSetter, CrossApplyExpression, CrossJoinExpression, DeleteExpression, DistinctExpression, ExceptExpression, ExistsExpression, FromSqlExpression, InExpression, InnerJoinExpression, IntersectExpression, JsonScalarExpression, LeftJoinExpression, LikeExpression, OrderingExpression, OuterApplyExpression, ProjectionExpression, RightJoinExpression, RowNumberExpression, RowValueExpression, ScalarSubqueryExpression, SelectExpression, SetOperationBase, SqlBinaryExpression, SqlConstantExpression, SqlExpression, SqlFragmentExpression, SqlFunctionExpression, SqlParameterExpression, SqlUnaryExpression, TableExpression, TableExpressionBase, TableValuedFunctionExpression, UnionExpression, UpdateExpression, ValuesExpression } from "../../Microsoft.EntityFrameworkCore.Query.SqlExpressions/internal/index.js";
import type { JsonReaderData } from "../../Microsoft.EntityFrameworkCore.Storage.Json/internal/index.js";
import type { IExceptionDetector, IExecutionStrategy, IntTypeMapping, IParameterNameGeneratorFactory, IRelationalCommand, IRelationalCommandBuilder, IRelationalCommandBuilderFactory, IRelationalConnection, IRelationalTypeMappingSource, ISqlGenerationHelper, ITypeMappingSource, MaterializationContext, ReaderColumn, RelationalCommandBuilderDependencies, RelationalTypeMapping } from "../../Microsoft.EntityFrameworkCore.Storage/internal/index.js";
import type { DbContext, DbLoggerCategory_Database_Command, DbLoggerCategory_Query, ParameterTranslationMode, QuerySplittingBehavior, QueryTrackingBehavior } from "../../Microsoft.EntityFrameworkCore/internal/index.js";
import * as System_Collections_Generic_Internal from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
import type { Dictionary_2, HashSet_1, IAsyncEnumerable_1, ICollection_1, IEnumerable_1, IEqualityComparer_1, IReadOnlyCollection_1, IReadOnlyDictionary_2, IReadOnlyList_1, IReadOnlySet_1, ISet_1, List_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 } from "@tsonic/dotnet/System.Collections/internal/index.js";
import type { DbCommand, DbDataReader } from "@tsonic/dotnet/System.Data.Common/internal/index.js";
import * as System_Linq_Expressions_Internal from "@tsonic/dotnet/System.Linq.Expressions/internal/index.js";
import type { BinaryExpression, BlockExpression, ConditionalExpression, ConstantExpression, DefaultExpression, Expression, Expression_1, ExpressionType, ExpressionVisitor, GotoExpression, IndexExpression, InvocationExpression, LabelExpression, LambdaExpression, ListInitExpression, LoopExpression, MemberExpression, MemberInitExpression, MethodCallExpression, NewArrayExpression, NewExpression, ParameterExpression, SwitchExpression, TryExpression, TypeBinaryExpression, 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, IQueryProvider } from "@tsonic/dotnet/System.Linq/internal/index.js";
import type { MemberInfo, MethodInfo } from "@tsonic/dotnet/System.Reflection/internal/index.js";
import type { StringBuilder } from "@tsonic/dotnet/System.Text/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, Action_3, Attribute, Boolean as ClrBoolean, Char, Enum, Exception, Func_1, Func_2, Func_3, Func_4, Func_5, IComparable, IConvertible, IDisposable, IEquatable_1, IFormattable, Int32, ISpanFormattable, Nullable_1, Object as ClrObject, ReadOnlySpan_1, String as ClrString, 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";

export enum ResultCardinality {
    Enumerable = 0,
    Single = 1,
    SingleOrDefault = 2
}


export interface IAggregateMethodCallTranslator$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IAggregateMethodCallTranslator: never;

    Translate(method: MethodInfo, source: EnumerableExpression, arguments: IReadOnlyList_1<SqlExpression>, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export type IAggregateMethodCallTranslator = IAggregateMethodCallTranslator$instance;

export interface IAggregateMethodCallTranslatorPlugin$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IAggregateMethodCallTranslatorPlugin: never;

    readonly Translators: IEnumerable_1<IAggregateMethodCallTranslator>;
}


export type IAggregateMethodCallTranslatorPlugin = IAggregateMethodCallTranslatorPlugin$instance;

export interface IAggregateMethodCallTranslatorProvider$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IAggregateMethodCallTranslatorProvider: never;

    Translate(model: IModel, method: MethodInfo, source: EnumerableExpression, arguments: IReadOnlyList_1<SqlExpression>, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export type IAggregateMethodCallTranslatorProvider = IAggregateMethodCallTranslatorProvider$instance;

export interface IAsyncQueryProvider$instance extends IQueryProvider {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IAsyncQueryProvider: never;

    ExecuteAsync<TResult extends unknown>(expression: Expression, cancellationToken?: CancellationToken): TResult;
}


export interface IAsyncQueryProvider$instance extends System_Linq_Internal.IQueryProvider {}

export type IAsyncQueryProvider = IAsyncQueryProvider$instance;

export interface ICompiledQueryCacheKeyGenerator$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ICompiledQueryCacheKeyGenerator: never;

    GenerateCacheKey(query: Expression, async: boolean): unknown;
}


export type ICompiledQueryCacheKeyGenerator = ICompiledQueryCacheKeyGenerator$instance;

export interface IEntityMaterializerSource$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IEntityMaterializerSource: never;

}


export type IEntityMaterializerSource = IEntityMaterializerSource$instance;

export interface IEvaluatableExpressionFilter$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IEvaluatableExpressionFilter: never;

    IsEvaluatableExpression(expression: Expression, model: IModel): boolean;
}


export type IEvaluatableExpressionFilter = IEvaluatableExpressionFilter$instance;

export interface IEvaluatableExpressionFilterPlugin$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IEvaluatableExpressionFilterPlugin: never;

    IsEvaluatableExpression(expression: Expression): boolean;
}


export type IEvaluatableExpressionFilterPlugin = IEvaluatableExpressionFilterPlugin$instance;

export interface IIncludableQueryable_2$instance<TEntity extends unknown, TProperty extends unknown> extends IQueryable_1<TEntity>, IEnumerable_1<TEntity>, IEnumerable, IQueryable {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IIncludableQueryable_2: never;

}


export interface IIncludableQueryable_2$instance<TEntity extends unknown, TProperty extends unknown> extends System_Collections_Generic_Internal.IEnumerable_1<TEntity>, System_Linq_Internal.IQueryable_1<TEntity> {}

export type IIncludableQueryable_2<TEntity extends unknown, TProperty extends unknown> = IIncludableQueryable_2$instance<TEntity, TProperty>;

export interface ILiftableConstantFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ILiftableConstantFactory: never;

    CreateLiftableConstant(originalValue: unknown | null, resolverExpression: Expression_1<Func_2<MaterializerLiftableConstantContext, unknown>>, variableName: string, type: Type): Expression;
}


export type ILiftableConstantFactory = ILiftableConstantFactory$instance;

export interface ILiftableConstantProcessor$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ILiftableConstantProcessor: never;

    readonly LiftedConstants: IReadOnlyList_1<ValueTuple_2<ParameterExpression, Expression>>;
    InlineConstants(expression: Expression, supportsPrecompiledQuery: boolean): Expression;
    LiftConstants(expression: Expression, contextParameter: ParameterExpression, variableNames: HashSet_1<System_Internal.String>): Expression;
}


export type ILiftableConstantProcessor = ILiftableConstantProcessor$instance;

export interface IMemberTranslator$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IMemberTranslator: never;

    Translate(instance: SqlExpression | null, member: MemberInfo, returnType: Type, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export type IMemberTranslator = IMemberTranslator$instance;

export interface IMemberTranslatorPlugin$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IMemberTranslatorPlugin: never;

    readonly Translators: IEnumerable_1<IMemberTranslator>;
}


export type IMemberTranslatorPlugin = IMemberTranslatorPlugin$instance;

export interface IMemberTranslatorProvider$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IMemberTranslatorProvider: never;

    Translate(instance: SqlExpression | null, member: MemberInfo, returnType: Type, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export type IMemberTranslatorProvider = IMemberTranslatorProvider$instance;

export interface IMethodCallTranslator$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IMethodCallTranslator: never;

    Translate(instance: SqlExpression | null, method: MethodInfo, arguments: IReadOnlyList_1<SqlExpression>, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export type IMethodCallTranslator = IMethodCallTranslator$instance;

export interface IMethodCallTranslatorPlugin$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IMethodCallTranslatorPlugin: never;

    readonly Translators: IEnumerable_1<IMethodCallTranslator>;
}


export type IMethodCallTranslatorPlugin = IMethodCallTranslatorPlugin$instance;

export interface IMethodCallTranslatorProvider$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IMethodCallTranslatorProvider: never;

    Translate(model: IModel, instance: SqlExpression | null, method: MethodInfo, arguments: IReadOnlyList_1<SqlExpression>, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export type IMethodCallTranslatorProvider = IMethodCallTranslatorProvider$instance;

export interface INavigationExpansionExtensibilityHelper$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_INavigationExpansionExtensibilityHelper: never;

    AreQueryRootsCompatible(first: EntityQueryRootExpression | null, second: EntityQueryRootExpression | null): boolean;
    CreateQueryRoot(entityType: IEntityType, source: EntityQueryRootExpression | null): EntityQueryRootExpression;
    ValidateQueryRootCreation(entityType: IEntityType, source: EntityQueryRootExpression | null): void;
}


export type INavigationExpansionExtensibilityHelper = INavigationExpansionExtensibilityHelper$instance;

export interface IPrintableExpression$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    Print(expressionPrinter: ExpressionPrinter): void;
}


export type IPrintableExpression = IPrintableExpression$instance;

export interface IQueryableMethodTranslatingExpressionVisitorFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IQueryableMethodTranslatingExpressionVisitorFactory: never;

    Create(queryCompilationContext: QueryCompilationContext): QueryableMethodTranslatingExpressionVisitor;
}


export type IQueryableMethodTranslatingExpressionVisitorFactory = IQueryableMethodTranslatingExpressionVisitorFactory$instance;

export interface IQueryCompilationContextFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IQueryCompilationContextFactory: never;

    Create(async: boolean): QueryCompilationContext;
}


export type IQueryCompilationContextFactory = IQueryCompilationContextFactory$instance;

export interface IQueryContextFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IQueryContextFactory: never;

    Create(): QueryContext;
}


export type IQueryContextFactory = IQueryContextFactory$instance;

export interface IQueryingEnumerable$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IQueryingEnumerable: never;

    ToQueryString(): string;
}


export type IQueryingEnumerable = IQueryingEnumerable$instance;

export interface IQuerySqlGeneratorFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IQuerySqlGeneratorFactory: never;

    Create(): QuerySqlGenerator;
}


export type IQuerySqlGeneratorFactory = IQuerySqlGeneratorFactory$instance;

export interface IQueryTranslationPostprocessorFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IQueryTranslationPostprocessorFactory: never;

    Create(queryCompilationContext: QueryCompilationContext): QueryTranslationPostprocessor;
}


export type IQueryTranslationPostprocessorFactory = IQueryTranslationPostprocessorFactory$instance;

export interface IQueryTranslationPreprocessorFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IQueryTranslationPreprocessorFactory: never;

    Create(queryCompilationContext: QueryCompilationContext): QueryTranslationPreprocessor;
}


export type IQueryTranslationPreprocessorFactory = IQueryTranslationPreprocessorFactory$instance;

export interface IRelationalLiftableConstantFactory$instance extends ILiftableConstantFactory {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IRelationalLiftableConstantFactory: never;

    CreateLiftableConstant(originalValue: unknown | null, resolverExpression: Expression_1<Func_2<MaterializerLiftableConstantContext, unknown>>, variableName: string, type: Type): Expression;
    CreateLiftableConstant(originalValue: unknown | null, resolverExpression: Expression_1<Func_2<RelationalMaterializerLiftableConstantContext, unknown>>, variableName: string, type: Type): LiftableConstantExpression;
}


export interface IRelationalLiftableConstantFactory$instance extends ILiftableConstantFactory$instance {}

export type IRelationalLiftableConstantFactory = IRelationalLiftableConstantFactory$instance;

export interface IRelationalParameterBasedSqlProcessorFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IRelationalParameterBasedSqlProcessorFactory: never;

    Create(parameters: RelationalParameterBasedSqlProcessorParameters): RelationalParameterBasedSqlProcessor;
}


export type IRelationalParameterBasedSqlProcessorFactory = IRelationalParameterBasedSqlProcessorFactory$instance;

export interface IRelationalQueryStringFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IRelationalQueryStringFactory: never;

    Create(command: DbCommand): string;
}


export type IRelationalQueryStringFactory = IRelationalQueryStringFactory$instance;

export interface IRelationalQuotableExpression$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IRelationalQuotableExpression: never;

    Quote(): Expression;
}


export type IRelationalQuotableExpression = IRelationalQuotableExpression$instance;

export interface IRelationalSqlTranslatingExpressionVisitorFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IRelationalSqlTranslatingExpressionVisitorFactory: never;

    Create(queryCompilationContext: QueryCompilationContext, queryableMethodTranslatingExpressionVisitor: QueryableMethodTranslatingExpressionVisitor): RelationalSqlTranslatingExpressionVisitor;
}


export type IRelationalSqlTranslatingExpressionVisitorFactory = IRelationalSqlTranslatingExpressionVisitorFactory$instance;

export interface IShapedQueryCompilingExpressionVisitorFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IShapedQueryCompilingExpressionVisitorFactory: never;

    Create(queryCompilationContext: QueryCompilationContext): ShapedQueryCompilingExpressionVisitor;
}


export type IShapedQueryCompilingExpressionVisitorFactory = IShapedQueryCompilingExpressionVisitorFactory$instance;

export interface ISqlAliasManagerFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ISqlAliasManagerFactory: never;

    Create(): SqlAliasManager;
}


export type ISqlAliasManagerFactory = ISqlAliasManagerFactory$instance;

export interface ISqlExpressionFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ISqlExpressionFactory: never;

    Add(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    ApplyDefaultTypeMapping(sqlExpression: SqlExpression | null): SqlExpression | null;
    ApplyTypeMapping(sqlExpression: SqlExpression | null, typeMapping: RelationalTypeMapping | null): SqlExpression | null;
    Case(operand: SqlExpression | null, whenClauses: IReadOnlyList_1<CaseWhenClause>, elseResult: SqlExpression | null, existingExpression?: SqlExpression | null): SqlExpression;
    Case(whenClauses: IReadOnlyList_1<CaseWhenClause>, elseResult: SqlExpression | null): SqlExpression;
    Constant(value: unknown, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Constant(value: unknown, sensitive: boolean, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Constant(value: unknown | null, type: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Constant(value: unknown | null, type: Type, sensitive: boolean, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Convert(operand: SqlExpression, type: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Equal(left: SqlExpression, right: SqlExpression): SqlExpression;
    Exists(subquery: SelectExpression): SqlExpression;
    Fragment(sql: string, type?: Type | null, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Function(instance: SqlExpression, name: string, arguments: IEnumerable_1<SqlExpression>, nullable: boolean, instancePropagatesNullability: boolean, argumentsPropagateNullability: IEnumerable_1<System_Internal.Boolean>, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Function(name: string, arguments: IEnumerable_1<SqlExpression>, nullable: boolean, argumentsPropagateNullability: IEnumerable_1<System_Internal.Boolean>, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Function(schema: string | null, name: string, arguments: IEnumerable_1<SqlExpression>, nullable: boolean, argumentsPropagateNullability: IEnumerable_1<System_Internal.Boolean>, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    In(item: SqlExpression, subquery: SelectExpression): SqlExpression;
    In(item: SqlExpression, valuesParameter: SqlParameterExpression): SqlExpression;
    In(item: SqlExpression, values: IReadOnlyList_1<SqlExpression>): SqlExpression;
    Like(match: SqlExpression, pattern: SqlExpression, escapeChar?: SqlExpression | null): SqlExpression;
    MakeBinary(operatorType: ExpressionType, left: SqlExpression, right: SqlExpression, typeMapping: RelationalTypeMapping | null, existingExpression?: SqlExpression | null): SqlExpression | null;
    MakeUnary(operatorType: ExpressionType, operand: SqlExpression, type: Type, typeMapping?: RelationalTypeMapping | null, existingExpression?: SqlExpression | null): SqlExpression | null;
    NiladicFunction(instance: SqlExpression, name: string, nullable: boolean, instancePropagatesNullability: boolean, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    NiladicFunction(name: string, nullable: boolean, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    NiladicFunction(schema: string, name: string, nullable: boolean, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
}


export type ISqlExpressionFactory = ISqlExpressionFactory$instance;

export interface IStructuralTypeMaterializerSource$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IStructuralTypeMaterializerSource: never;

    CreateMaterializeExpression(parameters: StructuralTypeMaterializerSourceParameters, materializationExpression: Expression): Expression;
    GetMaterializer(complexType: IComplexType): Func_2<MaterializationContext, unknown>;
    GetMaterializer(entityType: IEntityType): Func_2<MaterializationContext, unknown>;
}


export type IStructuralTypeMaterializerSource = IStructuralTypeMaterializerSource$instance;

export interface EntityMaterializerSourceParameters$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_EntityMaterializerSourceParameters: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    InstanceName: string;
    get QueryTrackingBehavior(): Nullable_1<QueryTrackingBehavior>;
    set QueryTrackingBehavior(value: Nullable_1<QueryTrackingBehavior> | QueryTrackingBehavior);
    StructuralType: ITypeBase;
    Deconstruct(StructuralType: ITypeBase, InstanceName: string, QueryTrackingBehavior: Nullable_1<QueryTrackingBehavior>): void;
    Equals(obj: unknown): boolean;
    Equals(other: EntityMaterializerSourceParameters): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const EntityMaterializerSourceParameters: {
    new(StructuralType: ITypeBase, InstanceName: string, QueryTrackingBehavior: Nullable_1<QueryTrackingBehavior>): EntityMaterializerSourceParameters;
};


export type EntityMaterializerSourceParameters = EntityMaterializerSourceParameters$instance;

export interface PathSegment$instance extends IRelationalQuotableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_PathSegment: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IRelationalQuotableExpression: never;

    readonly ArrayIndex: SqlExpression | null;
    readonly PropertyName: string | null;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    Quote(): Expression;
    ToString(): string;
}


export const PathSegment: {
    new(propertyName: string): PathSegment;
    new(arrayIndex: SqlExpression): PathSegment;
};


export interface __PathSegment$views {
    As_IRelationalQuotableExpression(): IRelationalQuotableExpression$instance;
}

export type PathSegment = PathSegment$instance & __PathSegment$views;


export interface StructuralTypeMaterializerSourceParameters$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_StructuralTypeMaterializerSourceParameters: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    ClrType: Type;
    InstanceName: string;
    IsNullable: boolean;
    get QueryTrackingBehavior(): Nullable_1<QueryTrackingBehavior>;
    set QueryTrackingBehavior(value: Nullable_1<QueryTrackingBehavior> | QueryTrackingBehavior);
    StructuralType: ITypeBase;
    Deconstruct(StructuralType: ITypeBase, InstanceName: string, ClrType: Type, IsNullable: boolean, QueryTrackingBehavior: Nullable_1<QueryTrackingBehavior>): void;
    Equals(obj: unknown): boolean;
    Equals(other: StructuralTypeMaterializerSourceParameters): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const StructuralTypeMaterializerSourceParameters: {
    new(StructuralType: ITypeBase, InstanceName: string, ClrType: Type, IsNullable: boolean, QueryTrackingBehavior: Nullable_1<QueryTrackingBehavior>): StructuralTypeMaterializerSourceParameters;
};


export type StructuralTypeMaterializerSourceParameters = StructuralTypeMaterializerSourceParameters$instance;

export interface CollectionResultExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_CollectionResultExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly ElementType: Type;
    readonly Navigation: INavigationBase | null;
    readonly NodeType: ExpressionType;
    readonly ProjectionBindingExpression: ProjectionBindingExpression;
    readonly QueryExpression: Expression;
    readonly StructuralProperty: IPropertyBase | null;
    readonly Type: Type;
    Print(expressionPrinter: ExpressionPrinter): void;
    Update(queryExpression: Expression): CollectionResultExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const CollectionResultExpression: {
    new(queryExpression: Expression, structuralProperty: IPropertyBase | null, elementType: Type): CollectionResultExpression;
};


export interface __CollectionResultExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type CollectionResultExpression = CollectionResultExpression$instance & __CollectionResultExpression$views;


export interface CompiledQueryCacheKeyGenerator$instance extends ICompiledQueryCacheKeyGenerator$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_CompiledQueryCacheKeyGenerator: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ICompiledQueryCacheKeyGenerator: never;

    readonly Dependencies: CompiledQueryCacheKeyGeneratorDependencies;
    GenerateCacheKey(query: Expression, async: boolean): unknown;
}


export const CompiledQueryCacheKeyGenerator: {
    new(dependencies: CompiledQueryCacheKeyGeneratorDependencies): CompiledQueryCacheKeyGenerator;
};


export interface __CompiledQueryCacheKeyGenerator$views {
    As_ICompiledQueryCacheKeyGenerator(): ICompiledQueryCacheKeyGenerator$instance;
}

export type CompiledQueryCacheKeyGenerator = CompiledQueryCacheKeyGenerator$instance & __CompiledQueryCacheKeyGenerator$views;


export interface CompiledQueryCacheKeyGenerator_CompiledQueryCacheKey$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_CompiledQueryCacheKeyGenerator_CompiledQueryCacheKey: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Equals(obj: unknown | null): boolean;
    Equals(other: CompiledQueryCacheKeyGenerator_CompiledQueryCacheKey): boolean;
    GetHashCode(): int;
}


export const CompiledQueryCacheKeyGenerator_CompiledQueryCacheKey: {
    new(query: Expression, model: IModel, queryTrackingBehavior: QueryTrackingBehavior, async: boolean): CompiledQueryCacheKeyGenerator_CompiledQueryCacheKey;
};


export type CompiledQueryCacheKeyGenerator_CompiledQueryCacheKey = CompiledQueryCacheKeyGenerator_CompiledQueryCacheKey$instance;

export interface CompiledQueryCacheKeyGeneratorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_CompiledQueryCacheKeyGeneratorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    CurrentContext: ICurrentDbContext;
    IsRetryingExecutionStrategy: boolean;
    Model: IModel;
    _Clone_$(): CompiledQueryCacheKeyGeneratorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: CompiledQueryCacheKeyGeneratorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const CompiledQueryCacheKeyGeneratorDependencies: {
    new(model: IModel, currentContext: ICurrentDbContext, executionStrategy: IExecutionStrategy): CompiledQueryCacheKeyGeneratorDependencies;
};


export type CompiledQueryCacheKeyGeneratorDependencies = CompiledQueryCacheKeyGeneratorDependencies$instance;

export interface EntityQueryRootExpression$instance extends QueryRootExpression$instance, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_EntityQueryRootExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly CanReduce: boolean;
    readonly EntityType: IEntityType;
    readonly NodeType: ExpressionType;
    DetachQueryProvider(): Expression;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    Print(expressionPrinter: ExpressionPrinter): void;
    UpdateEntityType(entityType: IEntityType): EntityQueryRootExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const EntityQueryRootExpression: {
    new(asyncQueryProvider: IAsyncQueryProvider, entityType: IEntityType): EntityQueryRootExpression;
    new(entityType: IEntityType): EntityQueryRootExpression;
};


export interface __EntityQueryRootExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type EntityQueryRootExpression = EntityQueryRootExpression$instance & __EntityQueryRootExpression$views;


export interface EnumerableExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_EnumerableExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly IsDistinct: boolean;
    readonly NodeType: ExpressionType;
    readonly Orderings: IReadOnlyList_1<OrderingExpression>;
    readonly Predicate: SqlExpression | null;
    readonly Selector: Expression;
    readonly Type: Type;
    AppendOrdering(orderingExpression: OrderingExpression): EnumerableExpression;
    ApplyOrdering(orderingExpression: OrderingExpression): EnumerableExpression;
    ApplyPredicate(sqlExpression: SqlExpression): EnumerableExpression;
    ApplySelector(expression: Expression): EnumerableExpression;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    Print(expressionPrinter: ExpressionPrinter): void;
    SetDistinct(value: boolean): EnumerableExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const EnumerableExpression: {
    new(selector: Expression): EnumerableExpression;
};


export interface __EnumerableExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type EnumerableExpression = EnumerableExpression$instance & __EnumerableExpression$views;


export interface EvaluatableExpressionFilter$instance extends IEvaluatableExpressionFilter$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_EvaluatableExpressionFilter: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IEvaluatableExpressionFilter: never;

    readonly Dependencies: EvaluatableExpressionFilterDependencies;
    IsEvaluatableExpression(expression: Expression, model: IModel): boolean;
}


export const EvaluatableExpressionFilter: {
    new(dependencies: EvaluatableExpressionFilterDependencies): EvaluatableExpressionFilter;
};


export interface __EvaluatableExpressionFilter$views {
    As_IEvaluatableExpressionFilter(): IEvaluatableExpressionFilter$instance;
}

export type EvaluatableExpressionFilter = EvaluatableExpressionFilter$instance & __EvaluatableExpressionFilter$views;


export interface EvaluatableExpressionFilterDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_EvaluatableExpressionFilterDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


export const EvaluatableExpressionFilterDependencies: {
    new(plugins: IEnumerable_1<IEvaluatableExpressionFilterPlugin>): EvaluatableExpressionFilterDependencies;
};


export type EvaluatableExpressionFilterDependencies = EvaluatableExpressionFilterDependencies$instance;

export interface ExpressionEqualityComparer$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ExpressionEqualityComparer: never;

    readonly __tsonic_iface_System_Collections_Generic_IEqualityComparer_1: never;

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


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


export type ExpressionEqualityComparer = ExpressionEqualityComparer$instance;

export interface ExpressionPrinter$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ExpressionPrinter: never;

    Append(value: string): ExpressionPrinter;
    AppendLine(): ExpressionPrinter;
    AppendLine(value: string): ExpressionPrinter;
    AppendLines(value: string, skipFinalNewline?: boolean): ExpressionPrinter;
    GenerateBinaryOperator(expressionType: ExpressionType): string;
    Indent(): IDisposable;
    PrintExpression(expression: Expression, characterLimit?: Nullable_1<System_Internal.Int32>): string;
    PrintExpressionDebug(expression: Expression): string;
    ToString(): string;
    Visit(expression: Expression | null): Expression | null;
    VisitBinary(binaryExpression: BinaryExpression): Expression;
    VisitBlock(blockExpression: BlockExpression): Expression;
    VisitCollection<T extends unknown & Expression>(items: IReadOnlyCollection_1<T>, joinAction?: Action_1<ExpressionPrinter> | null): void;
    VisitConditional(conditionalExpression: ConditionalExpression): Expression;
    VisitConstant(constantExpression: ConstantExpression): Expression;
    VisitDefault(defaultExpression: DefaultExpression): Expression;
    VisitExtension(extensionExpression: Expression): Expression;
    VisitGoto(gotoExpression: GotoExpression): Expression;
    VisitIndex(indexExpression: IndexExpression): Expression;
    VisitInvocation(invocationExpression: InvocationExpression): Expression;
    VisitLabel(labelExpression: LabelExpression): Expression;
    VisitLambda<T extends unknown>(lambdaExpression: Expression_1<T>): Expression;
    VisitLoop(loopExpression: LoopExpression): Expression;
    VisitMember(memberExpression: MemberExpression): Expression;
    VisitMemberInit(memberInitExpression: MemberInitExpression): Expression;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
    VisitNew(newExpression: NewExpression): Expression;
    VisitNewArray(newArrayExpression: NewArrayExpression): Expression;
    VisitParameter(parameterExpression: ParameterExpression): Expression;
    VisitSwitch(switchExpression: SwitchExpression): Expression;
    VisitTry(tryExpression: TryExpression): Expression;
    VisitTypeBinary(typeBinaryExpression: TypeBinaryExpression): Expression;
    VisitUnary(unaryExpression: UnaryExpression): Expression;
}


export const ExpressionPrinter: {
    new(): ExpressionPrinter;
    Print(expression: Expression): string;
    PrintDebug(expression: Expression): string;
};


export type ExpressionPrinter = ExpressionPrinter$instance;

export interface GroupByShaperExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_GroupByShaperExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly GroupingEnumerable: ShapedQueryExpression;
    readonly KeySelector: Expression;
    readonly NodeType: ExpressionType;
    readonly Type: Type;
    Print(expressionPrinter: ExpressionPrinter): void;
    Update(keySelector: Expression, groupingEnumerable: ShapedQueryExpression): GroupByShaperExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const GroupByShaperExpression: {
    new(keySelector: Expression, groupingEnumerable: ShapedQueryExpression): GroupByShaperExpression;
};


export interface __GroupByShaperExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type GroupByShaperExpression = GroupByShaperExpression$instance & __GroupByShaperExpression$views;


export interface IncludeExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_IncludeExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly EntityExpression: Expression;
    readonly Navigation: INavigationBase;
    readonly NavigationExpression: Expression;
    readonly NodeType: ExpressionType;
    readonly SetLoaded: boolean;
    readonly Type: Type;
    Update(entityExpression: Expression, navigationExpression: Expression): IncludeExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const IncludeExpression: {
    new(entityExpression: Expression, navigationExpression: Expression, navigation: INavigationBase): IncludeExpression;
    new(entityExpression: Expression, navigationExpression: Expression, navigation: INavigationBase, setLoaded: boolean): IncludeExpression;
};


export interface __IncludeExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type IncludeExpression = IncludeExpression$instance & __IncludeExpression$views;


export interface InlineQueryRootExpression$instance extends QueryRootExpression$instance, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_InlineQueryRootExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly Values: IReadOnlyList_1<Expression>;
    DetachQueryProvider(): Expression;
    Print(expressionPrinter: ExpressionPrinter): void;
    Update(values: IReadOnlyList_1<Expression>): InlineQueryRootExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const InlineQueryRootExpression: {
    new(asyncQueryProvider: IAsyncQueryProvider, values: IReadOnlyList_1<Expression>, elementType: Type): InlineQueryRootExpression;
    new(values: IReadOnlyList_1<Expression>, elementType: Type): InlineQueryRootExpression;
};


export interface __InlineQueryRootExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type InlineQueryRootExpression = InlineQueryRootExpression$instance & __InlineQueryRootExpression$views;


export interface JsonQueryExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_JsonQueryExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly IsCollection: boolean;
    readonly IsNullable: boolean;
    readonly JsonColumn: ColumnExpression;
    readonly KeyPropertyMap: IReadOnlyDictionary_2<IProperty, ColumnExpression> | null;
    readonly NodeType: ExpressionType;
    readonly Path: IReadOnlyList_1<PathSegment>;
    readonly StructuralType: ITypeBase;
    readonly Type: Type;
    BindCollectionElement(collectionIndexExpression: SqlExpression): JsonQueryExpression;
    BindProperty(property: IProperty): SqlExpression;
    BindStructuralProperty(structuralProperty: IPropertyBase): JsonQueryExpression;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    MakeNullable(): JsonQueryExpression;
    Print(expressionPrinter: ExpressionPrinter): void;
    Update(jsonColumn: ColumnExpression, keyPropertyMap: IReadOnlyDictionary_2<IProperty, ColumnExpression> | null): JsonQueryExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const JsonQueryExpression: {
    new(structuralType: ITypeBase, jsonColumn: ColumnExpression, keyPropertyMap: IReadOnlyDictionary_2<IProperty, ColumnExpression> | null, type: Type, collection: boolean): JsonQueryExpression;
    new(structuralType: ITypeBase, jsonColumn: ColumnExpression, keyPropertyMap: IReadOnlyDictionary_2<IProperty, ColumnExpression> | null, path: IReadOnlyList_1<PathSegment>, type: Type, collection: boolean, nullable: boolean): JsonQueryExpression;
};


export interface __JsonQueryExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type JsonQueryExpression = JsonQueryExpression$instance & __JsonQueryExpression$views;


export interface LiftableConstantExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_LiftableConstantExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly NodeType: ExpressionType;
    readonly OriginalExpression: ConstantExpression;
    readonly ResolverExpression: LambdaExpression;
    readonly Type: Type;
    readonly VariableName: string;
    Print(expressionPrinter: ExpressionPrinter): void;
    Update(resolverExpression: LambdaExpression): LiftableConstantExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const LiftableConstantExpression: {
    new(originalValue: unknown | null, resolverExpression: LambdaExpression, variableName: string, type: Type): LiftableConstantExpression;
};


export interface __LiftableConstantExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type LiftableConstantExpression = LiftableConstantExpression$instance & __LiftableConstantExpression$views;


export interface LiftableConstantExpressionDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_LiftableConstantExpressionDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


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


export type LiftableConstantExpressionDependencies = LiftableConstantExpressionDependencies$instance;

export interface LiftableConstantFactory$instance extends ILiftableConstantFactory$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_LiftableConstantFactory: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ILiftableConstantFactory: never;

    readonly Dependencies: LiftableConstantExpressionDependencies;
    CreateLiftableConstant(originalValue: unknown | null, resolverExpression: Expression_1<Func_2<MaterializerLiftableConstantContext, unknown>>, variableName: string, type: Type): Expression;
}


export const LiftableConstantFactory: {
    new(dependencies: LiftableConstantExpressionDependencies): LiftableConstantFactory;
};


export interface __LiftableConstantFactory$views {
    As_ILiftableConstantFactory(): ILiftableConstantFactory$instance;
}

export type LiftableConstantFactory = LiftableConstantFactory$instance & __LiftableConstantFactory$views;


export interface LiftableConstantProcessor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_LiftableConstantProcessor: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ILiftableConstantProcessor: never;

    LiftedConstants: IReadOnlyList_1<ValueTuple_2<ParameterExpression, Expression>>;
    InlineConstant(liftableConstant: LiftableConstantExpression): ConstantExpression;
    InlineConstants(expression: Expression, supportsPrecompiledQuery: boolean): Expression;
    LiftConstant(liftableConstant: LiftableConstantExpression): ParameterExpression;
    LiftConstants(expression: Expression, contextParameter: ParameterExpression, variableNames: HashSet_1<System_Internal.String>): Expression;
    VisitBinary(binaryExpression: BinaryExpression): Expression;
    VisitExtension(node: Expression): Expression;
}


export const LiftableConstantProcessor: {
    new(dependencies: ShapedQueryCompilingExpressionVisitorDependencies): LiftableConstantProcessor;
};


export interface __LiftableConstantProcessor$views {
    As_ILiftableConstantProcessor(): ILiftableConstantProcessor$instance;
}

export type LiftableConstantProcessor = LiftableConstantProcessor$instance & __LiftableConstantProcessor$views;


export interface MaterializeCollectionNavigationExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_MaterializeCollectionNavigationExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly Navigation: INavigationBase;
    readonly NodeType: ExpressionType;
    readonly Subquery: Expression;
    readonly Type: Type;
    Update(subquery: Expression): MaterializeCollectionNavigationExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const MaterializeCollectionNavigationExpression: {
    new(subquery: Expression, navigation: INavigationBase): MaterializeCollectionNavigationExpression;
};


export interface __MaterializeCollectionNavigationExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type MaterializeCollectionNavigationExpression = MaterializeCollectionNavigationExpression$instance & __MaterializeCollectionNavigationExpression$views;


export interface MaterializerLiftableConstantContext$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_MaterializerLiftableConstantContext: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Dependencies: ShapedQueryCompilingExpressionVisitorDependencies;
    readonly EqualityContract: Type;
    _Clone_$(): MaterializerLiftableConstantContext;
    Deconstruct(Dependencies: ShapedQueryCompilingExpressionVisitorDependencies): void;
    Equals(obj: unknown | null): boolean;
    Equals(other: MaterializerLiftableConstantContext | null): boolean;
    GetHashCode(): int;
    PrintMembers(builder: StringBuilder): boolean;
    ToString(): string;
}


export const MaterializerLiftableConstantContext: {
    new(Dependencies: ShapedQueryCompilingExpressionVisitorDependencies): MaterializerLiftableConstantContext;
};


export type MaterializerLiftableConstantContext = MaterializerLiftableConstantContext$instance;

export interface NavigationExpansionExtensibilityHelper$instance extends INavigationExpansionExtensibilityHelper$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_NavigationExpansionExtensibilityHelper: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_INavigationExpansionExtensibilityHelper: never;

    readonly Dependencies: NavigationExpansionExtensibilityHelperDependencies;
    AreQueryRootsCompatible(first: EntityQueryRootExpression | null, second: EntityQueryRootExpression | null): boolean;
    CreateQueryRoot(entityType: IEntityType, source: EntityQueryRootExpression | null): EntityQueryRootExpression;
    ValidateQueryRootCreation(entityType: IEntityType, source: EntityQueryRootExpression | null): void;
}


export const NavigationExpansionExtensibilityHelper: {
    new(dependencies: NavigationExpansionExtensibilityHelperDependencies): NavigationExpansionExtensibilityHelper;
};


export interface __NavigationExpansionExtensibilityHelper$views {
    As_INavigationExpansionExtensibilityHelper(): INavigationExpansionExtensibilityHelper$instance;
}

export type NavigationExpansionExtensibilityHelper = NavigationExpansionExtensibilityHelper$instance & __NavigationExpansionExtensibilityHelper$views;


export interface NavigationExpansionExtensibilityHelperDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_NavigationExpansionExtensibilityHelperDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


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


export type NavigationExpansionExtensibilityHelperDependencies = NavigationExpansionExtensibilityHelperDependencies$instance;

export interface NotParameterizedAttribute$instance extends Attribute {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_NotParameterizedAttribute: never;

}


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


export type NotParameterizedAttribute = NotParameterizedAttribute$instance;

export interface ParameterQueryRootExpression$instance extends QueryRootExpression$instance, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ParameterQueryRootExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly ParameterExpression: ParameterExpression;
    readonly QueryParameterExpression: QueryParameterExpression;
    DetachQueryProvider(): Expression;
    Print(expressionPrinter: ExpressionPrinter): void;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const ParameterQueryRootExpression: {
    new(asyncQueryProvider: IAsyncQueryProvider, elementType: Type, queryParameterExpression: QueryParameterExpression): ParameterQueryRootExpression;
    new(elementType: Type, queryParameterExpression: QueryParameterExpression): ParameterQueryRootExpression;
    new(asyncQueryProvider: IAsyncQueryProvider, elementType: Type, parameterExpression: ParameterExpression): ParameterQueryRootExpression;
    new(elementType: Type, parameterExpression: ParameterExpression): ParameterQueryRootExpression;
};


export interface __ParameterQueryRootExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type ParameterQueryRootExpression = ParameterQueryRootExpression$instance & __ParameterQueryRootExpression$views;


export interface ParametersCacheDecorator$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ParametersCacheDecorator: never;

    CanCache: boolean;
    GetAndDisableCaching(): Dictionary_2<System_Internal.String, unknown | null>;
    IsNull(parameterName: string): boolean;
}


export const ParametersCacheDecorator: {
    new(parameters: Dictionary_2<System_Internal.String, unknown | null>): ParametersCacheDecorator;
};


export type ParametersCacheDecorator = ParametersCacheDecorator$instance;

export interface ProjectionBindingExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ProjectionBindingExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly Index: Nullable_1<System_Internal.Int32>;
    readonly NodeType: ExpressionType;
    readonly ProjectionMember: ProjectionMember | null;
    readonly QueryExpression: Expression;
    readonly Type: Type;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const ProjectionBindingExpression: {
    new(queryExpression: Expression, projectionMember: ProjectionMember, type: Type): ProjectionBindingExpression;
    new(queryExpression: Expression, index: int, type: Type): ProjectionBindingExpression;
};


export interface __ProjectionBindingExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type ProjectionBindingExpression = ProjectionBindingExpression$instance & __ProjectionBindingExpression$views;


export interface ProjectionMember$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ProjectionMember: never;

    readonly Last: MemberInfo | null;
    Append(member: MemberInfo): ProjectionMember;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    Prepend(member: MemberInfo): ProjectionMember;
    ToString(): string;
}


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


export type ProjectionMember = ProjectionMember$instance;

export interface QueryableMethodTranslatingExpressionVisitor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryableMethodTranslatingExpressionVisitor: never;

    readonly Dependencies: QueryableMethodTranslatingExpressionVisitorDependencies;
    readonly QueryCompilationContext: QueryCompilationContext;
    get TranslationErrorDetails(): string | null;
    set TranslationErrorDetails(value: string | null);
    AddTranslationErrorDetails(details: string): void;
    CreateShapedQueryExpression(entityType: IEntityType): ShapedQueryExpression | null;
    CreateSubqueryVisitor(): QueryableMethodTranslatingExpressionVisitor;
    MarkShaperNullable(shaperExpression: Expression): Expression;
    Translate(expression: Expression): Expression;
    TranslateAll(source: ShapedQueryExpression, predicate: LambdaExpression): ShapedQueryExpression | null;
    TranslateAny(source: ShapedQueryExpression, predicate: LambdaExpression | null): ShapedQueryExpression | null;
    TranslateAverage(source: ShapedQueryExpression, selector: LambdaExpression | null, resultType: Type): ShapedQueryExpression | null;
    TranslateCast(source: ShapedQueryExpression, castType: Type): ShapedQueryExpression | null;
    TranslateConcat(source1: ShapedQueryExpression, source2: ShapedQueryExpression): ShapedQueryExpression | null;
    TranslateContains(source: ShapedQueryExpression, item: Expression): ShapedQueryExpression | null;
    TranslateCount(source: ShapedQueryExpression, predicate: LambdaExpression | null): ShapedQueryExpression | null;
    TranslateDefaultIfEmpty(source: ShapedQueryExpression, defaultValue: Expression | null): ShapedQueryExpression | null;
    TranslateDistinct(source: ShapedQueryExpression): ShapedQueryExpression | null;
    TranslateElementAtOrDefault(source: ShapedQueryExpression, index: Expression, returnDefault: boolean): ShapedQueryExpression | null;
    TranslateExcept(source1: ShapedQueryExpression, source2: ShapedQueryExpression): ShapedQueryExpression | null;
    TranslateExecuteDelete(source: ShapedQueryExpression): Expression | null;
    TranslateExecuteUpdate(source: ShapedQueryExpression, setters: IReadOnlyList_1<QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter>): Expression | null;
    TranslateFirstOrDefault(source: ShapedQueryExpression, predicate: LambdaExpression | null, returnType: Type, returnDefault: boolean): ShapedQueryExpression | null;
    TranslateGroupBy(source: ShapedQueryExpression, keySelector: LambdaExpression, elementSelector: LambdaExpression | null, resultSelector: LambdaExpression | null): ShapedQueryExpression | null;
    TranslateGroupJoin(outer: ShapedQueryExpression, inner: ShapedQueryExpression, outerKeySelector: LambdaExpression, innerKeySelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateInlineQueryRoot(inlineQueryRootExpression: InlineQueryRootExpression): ShapedQueryExpression | null;
    TranslateIntersect(source1: ShapedQueryExpression, source2: ShapedQueryExpression): ShapedQueryExpression | null;
    TranslateJoin(outer: ShapedQueryExpression, inner: ShapedQueryExpression, outerKeySelector: LambdaExpression, innerKeySelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateLastOrDefault(source: ShapedQueryExpression, predicate: LambdaExpression | null, returnType: Type, returnDefault: boolean): ShapedQueryExpression | null;
    TranslateLeftJoin(outer: ShapedQueryExpression, inner: ShapedQueryExpression, outerKeySelector: LambdaExpression, innerKeySelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateLongCount(source: ShapedQueryExpression, predicate: LambdaExpression | null): ShapedQueryExpression | null;
    TranslateMax(source: ShapedQueryExpression, selector: LambdaExpression | null, resultType: Type): ShapedQueryExpression | null;
    TranslateMemberAccess(source: Expression, member: MemberIdentity): ShapedQueryExpression | null;
    TranslateMin(source: ShapedQueryExpression, selector: LambdaExpression | null, resultType: Type): ShapedQueryExpression | null;
    TranslateOfType(source: ShapedQueryExpression, resultType: Type): ShapedQueryExpression | null;
    TranslateOrderBy(source: ShapedQueryExpression, keySelector: LambdaExpression, ascending: boolean): ShapedQueryExpression | null;
    TranslateParameterQueryRoot(parameterQueryRootExpression: ParameterQueryRootExpression): ShapedQueryExpression | null;
    TranslateReverse(source: ShapedQueryExpression): ShapedQueryExpression | null;
    TranslateRightJoin(outer: ShapedQueryExpression, inner: ShapedQueryExpression, outerKeySelector: LambdaExpression, innerKeySelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateSelect(source: ShapedQueryExpression, selector: LambdaExpression): ShapedQueryExpression;
    TranslateSelectMany(source: ShapedQueryExpression, collectionSelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateSelectMany(source: ShapedQueryExpression, selector: LambdaExpression): ShapedQueryExpression | null;
    TranslateSingleOrDefault(source: ShapedQueryExpression, predicate: LambdaExpression | null, returnType: Type, returnDefault: boolean): ShapedQueryExpression | null;
    TranslateSkip(source: ShapedQueryExpression, count: Expression): ShapedQueryExpression | null;
    TranslateSkipWhile(source: ShapedQueryExpression, predicate: LambdaExpression): ShapedQueryExpression | null;
    TranslateSubquery(expression: Expression): ShapedQueryExpression | null;
    TranslateSum(source: ShapedQueryExpression, selector: LambdaExpression | null, resultType: Type): ShapedQueryExpression | null;
    TranslateTake(source: ShapedQueryExpression, count: Expression): ShapedQueryExpression | null;
    TranslateTakeWhile(source: ShapedQueryExpression, predicate: LambdaExpression): ShapedQueryExpression | null;
    TranslateThenBy(source: ShapedQueryExpression, keySelector: LambdaExpression, ascending: boolean): ShapedQueryExpression | null;
    TranslateUnion(source1: ShapedQueryExpression, source2: ShapedQueryExpression): ShapedQueryExpression | null;
    TranslateWhere(source: ShapedQueryExpression, predicate: LambdaExpression): ShapedQueryExpression | null;
    VisitExtension(extensionExpression: Expression): Expression;
    VisitMember(memberExpression: MemberExpression): Expression;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
}


export const QueryableMethodTranslatingExpressionVisitor: (abstract new(dependencies: QueryableMethodTranslatingExpressionVisitorDependencies, queryCompilationContext: QueryCompilationContext, subquery: boolean) => QueryableMethodTranslatingExpressionVisitor) & {
};


export type QueryableMethodTranslatingExpressionVisitor = QueryableMethodTranslatingExpressionVisitor$instance;

export interface QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    PropertySelector: LambdaExpression;
    ValueExpression: Expression;
    _Clone_$(): QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter;
    Deconstruct(PropertySelector: LambdaExpression, ValueExpression: Expression): void;
    Equals(obj: unknown | null): boolean;
    Equals(other: QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter: {
    new(PropertySelector: LambdaExpression, ValueExpression: Expression): QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter;
};


export type QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter = QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter$instance;

export interface QueryableMethodTranslatingExpressionVisitorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryableMethodTranslatingExpressionVisitorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


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


export type QueryableMethodTranslatingExpressionVisitorDependencies = QueryableMethodTranslatingExpressionVisitorDependencies$instance;

export interface QueryCompilationContext$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryCompilationContext: never;

    readonly ContextOptions: IDbContextOptions;
    readonly ContextType: Type;
    readonly Dependencies: QueryCompilationContextDependencies;
    IgnoreAutoIncludes: boolean;
    get IgnoredQueryFilters(): HashSet_1<System_Internal.String> | null;
    set IgnoredQueryFilters(value: HashSet_1<System_Internal.String> | null);
    IgnoreQueryFilters: boolean;
    readonly IsAsync: boolean;
    readonly IsBuffering: boolean;
    readonly IsPrecompiling: boolean;
    readonly Logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>;
    readonly Model: IModel;
    QueryTrackingBehavior: QueryTrackingBehavior;
    readonly SupportsPrecompiledQuery: boolean;
    readonly Tags: ISet_1<System_Internal.String>;
    AddTag(tag: string): void;
    CreateQueryExecutor<TResult extends unknown>(query: Expression): Func_2<QueryContext, TResult>;
    CreateQueryExecutorExpression<TResult extends unknown>(query: Expression): Expression_1<Func_2<QueryContext, TResult>>;
    RegisterRuntimeParameter(name: string, valueExtractor: LambdaExpression): QueryParameterExpression;
}


export const QueryCompilationContext: {
    new(dependencies: QueryCompilationContextDependencies, async: boolean): QueryCompilationContext;
    new(dependencies: QueryCompilationContextDependencies, async: boolean, precompiling: boolean): QueryCompilationContext;
    readonly QueryContextParameter: ParameterExpression;
    readonly NotTranslatedExpression: Expression;
};


export type QueryCompilationContext = QueryCompilationContext$instance;

export interface QueryCompilationContextDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryCompilationContextDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    readonly Context: DbContext;
    ContextOptions: IDbContextOptions;
    readonly ContextType: Type;
    readonly Interceptors: IInterceptors;
    IsRetryingExecutionStrategy: boolean;
    LiftableConstantFactory: ILiftableConstantFactory;
    LiftableConstantProcessor: ILiftableConstantProcessor;
    Logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>;
    Model: IModel;
    QueryableMethodTranslatingExpressionVisitorFactory: IQueryableMethodTranslatingExpressionVisitorFactory;
    readonly QueryTrackingBehavior: QueryTrackingBehavior;
    QueryTranslationPostprocessorFactory: IQueryTranslationPostprocessorFactory;
    QueryTranslationPreprocessorFactory: IQueryTranslationPreprocessorFactory;
    ShapedQueryCompilingExpressionVisitorFactory: IShapedQueryCompilingExpressionVisitorFactory;
    _Clone_$(): QueryCompilationContextDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: QueryCompilationContextDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const QueryCompilationContextDependencies: {
    new(model: IModel, queryTranslationPreprocessorFactory: IQueryTranslationPreprocessorFactory, queryableMethodTranslatingExpressionVisitorFactory: IQueryableMethodTranslatingExpressionVisitorFactory, queryTranslationPostprocessorFactory: IQueryTranslationPostprocessorFactory, shapedQueryCompilingExpressionVisitorFactory: IShapedQueryCompilingExpressionVisitorFactory, liftableConstantFactory: ILiftableConstantFactory, liftableConstantProcessor: ILiftableConstantProcessor, executionStrategy: IExecutionStrategy, currentContext: ICurrentDbContext, contextOptions: IDbContextOptions, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>, interceptors: IInterceptors): QueryCompilationContextDependencies;
};


export type QueryCompilationContextDependencies = QueryCompilationContextDependencies$instance;

export interface QueryContext$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryContext: never;

    CancellationToken: CancellationToken;
    readonly CommandLogger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Command> | IRelationalCommandDiagnosticsLogger;
    readonly ConcurrencyDetector: IConcurrencyDetector;
    readonly Context: DbContext;
    readonly Dependencies: QueryContextDependencies;
    readonly ExceptionDetector: IExceptionDetector;
    readonly ExecutionStrategy: IExecutionStrategy;
    readonly Parameters: Dictionary_2<System_Internal.String, unknown | null>;
    readonly QueryLogger: IDiagnosticsLogger_1<DbLoggerCategory_Query>;
    InitializeStateManager(standAlone?: boolean): void;
    SetNavigationIsLoaded(entity: unknown, navigation: INavigationBase): void;
    StartTracking(entityType: IEntityType, entity: unknown, snapshot: ISnapshot): InternalEntityEntry;
    TryGetEntry(key: IKey, keyValues: unknown[], throwOnNullKey: boolean, hasNullKey: boolean): InternalEntityEntry | null;
}


export const QueryContext: (abstract new(dependencies: QueryContextDependencies) => QueryContext) & {
};


export type QueryContext = QueryContext$instance;

export interface QueryContextDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryContextDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    CommandLogger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Command>;
    ConcurrencyDetector: IConcurrencyDetector;
    CurrentContext: ICurrentDbContext;
    ExceptionDetector: IExceptionDetector;
    ExecutionStrategy: IExecutionStrategy;
    QueryLogger: IDiagnosticsLogger_1<DbLoggerCategory_Query>;
    readonly StateManager: IStateManager;
    _Clone_$(): QueryContextDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: QueryContextDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const QueryContextDependencies: {
    new(currentContext: ICurrentDbContext, executionStrategy: IExecutionStrategy, concurrencyDetector: IConcurrencyDetector, exceptionDetector: IExceptionDetector, commandLogger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Command>, queryLogger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): QueryContextDependencies;
};


export type QueryContextDependencies = QueryContextDependencies$instance;

export interface QueryParameterExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryParameterExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly IsNonNullableReferenceType: boolean;
    readonly Name: string;
    readonly NodeType: ExpressionType;
    readonly TranslationMode: Nullable_1<ParameterTranslationMode>;
    readonly Type: Type;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    Print(expressionPrinter: ExpressionPrinter): void;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const QueryParameterExpression: {
    new(name: string, type: Type): QueryParameterExpression;
    new(name: string, type: Type, translationMode: ParameterTranslationMode): QueryParameterExpression;
    new(name: string, type: Type, translationMode: Nullable_1<ParameterTranslationMode>, isNonNullableReferenceType: boolean): QueryParameterExpression;
};


export interface __QueryParameterExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type QueryParameterExpression = QueryParameterExpression$instance & __QueryParameterExpression$views;


export interface QueryRootExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryRootExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly CanReduce: boolean;
    readonly ElementType: Type;
    readonly NodeType: ExpressionType;
    readonly QueryProvider: IAsyncQueryProvider | null;
    readonly Type: Type;
    DetachQueryProvider(): Expression;
    Equals(obj: unknown | null): boolean;
    GetHashCode(): int;
    Print(expressionPrinter: ExpressionPrinter): void;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const QueryRootExpression: (abstract new(asyncQueryProvider: IAsyncQueryProvider, elementType: Type) => QueryRootExpression) & (abstract new(elementType: Type) => QueryRootExpression) & {
};


export interface __QueryRootExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type QueryRootExpression = QueryRootExpression$instance & __QueryRootExpression$views;


export interface QueryRootProcessor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryRootProcessor: never;

    ShouldConvertToInlineQueryRoot(expression: Expression): boolean;
    ShouldConvertToParameterQueryRoot(queryParameterExpression: QueryParameterExpression): boolean;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
}


export const QueryRootProcessor: {
    new(dependencies: QueryTranslationPreprocessorDependencies, queryCompilationContext: QueryCompilationContext): QueryRootProcessor;
};


export type QueryRootProcessor = QueryRootProcessor$instance;

export interface QuerySqlGenerator$instance extends SqlExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QuerySqlGenerator: never;

    readonly AliasSeparator: string;
    readonly Dependencies: QuerySqlGeneratorDependencies;
    readonly Sql: IRelationalCommandBuilder;
    CheckComposableSql(sql: string): void;
    CheckComposableSqlTrimmed(sql: ReadOnlySpan_1<System_Internal.Char>): void;
    GenerateEmptyProjection(selectExpression: SelectExpression): void;
    GenerateExists(existsExpression: ExistsExpression, negated: boolean): void;
    GenerateFrom(selectExpression: SelectExpression): void;
    GenerateIn(inExpression: InExpression, negated: boolean): void;
    GenerateLike(likeExpression: LikeExpression, negated: boolean): void;
    GenerateLimitOffset(selectExpression: SelectExpression): void;
    GenerateOrderings(selectExpression: SelectExpression): void;
    GenerateProjection(selectExpression: SelectExpression): void;
    GeneratePseudoFromClause(): void;
    GenerateRootCommand(queryExpression: Expression): void;
    GenerateSetOperation(setOperation: SetOperationBase): void;
    GenerateSetOperationOperand(setOperation: SetOperationBase, operand: SelectExpression): void;
    GenerateTagsHeaderComment(selectExpression: SelectExpression): void;
    GenerateTagsHeaderComment(tags: ISet_1<System_Internal.String>): void;
    GenerateTop(selectExpression: SelectExpression): void;
    GenerateValues(valuesExpression: ValuesExpression): void;
    GetCommand(queryExpression: Expression): IRelationalCommand;
    GetOperator(binaryExpression: SqlBinaryExpression): string;
    RequiresParentheses(outerExpression: SqlExpression, innerExpression: SqlExpression): boolean;
    TryGenerateWithoutWrappingSelect(selectExpression: SelectExpression): boolean;
    TryGetOperatorInfo(expression: SqlExpression, precedence: int, isAssociative: boolean): boolean;
    VisitAtTimeZone(atTimeZoneExpression: AtTimeZoneExpression): Expression;
    VisitCase(caseExpression: CaseExpression): Expression;
    VisitCollate(collateExpression: CollateExpression): Expression;
    VisitColumn(columnExpression: ColumnExpression): Expression;
    VisitCrossApply(crossApplyExpression: CrossApplyExpression): Expression;
    VisitCrossJoin(crossJoinExpression: CrossJoinExpression): Expression;
    VisitDelete(deleteExpression: DeleteExpression): Expression;
    VisitDistinct(distinctExpression: DistinctExpression): Expression;
    VisitExcept(exceptExpression: ExceptExpression): Expression;
    VisitExists(existsExpression: ExistsExpression): Expression;
    VisitFromSql(fromSqlExpression: FromSqlExpression): Expression;
    VisitIn(inExpression: InExpression): Expression;
    VisitInnerJoin(innerJoinExpression: InnerJoinExpression): Expression;
    VisitIntersect(intersectExpression: IntersectExpression): Expression;
    VisitJsonScalar(jsonScalarExpression: JsonScalarExpression): Expression;
    VisitLeftJoin(leftJoinExpression: LeftJoinExpression): Expression;
    VisitLike(likeExpression: LikeExpression): Expression;
    VisitOrdering(orderingExpression: OrderingExpression): Expression;
    VisitOuterApply(outerApplyExpression: OuterApplyExpression): Expression;
    VisitProjection(projectionExpression: ProjectionExpression): Expression;
    VisitRightJoin(rightJoinExpression: RightJoinExpression): Expression;
    VisitRowNumber(rowNumberExpression: RowNumberExpression): Expression;
    VisitRowValue(rowValueExpression: RowValueExpression): Expression;
    VisitScalarSubquery(scalarSubqueryExpression: ScalarSubqueryExpression): Expression;
    VisitSelect(selectExpression: SelectExpression): Expression;
    VisitSqlBinary(sqlBinaryExpression: SqlBinaryExpression): Expression;
    VisitSqlConstant(sqlConstantExpression: SqlConstantExpression): Expression;
    VisitSqlFragment(sqlFragmentExpression: SqlFragmentExpression): Expression;
    VisitSqlFunction(sqlFunctionExpression: SqlFunctionExpression): Expression;
    VisitSqlParameter(sqlParameterExpression: SqlParameterExpression): Expression;
    VisitSqlUnary(sqlUnaryExpression: SqlUnaryExpression): Expression;
    VisitTable(tableExpression: TableExpression): Expression;
    VisitTableValuedFunction(tableValuedFunctionExpression: TableValuedFunctionExpression): Expression;
    VisitUnion(unionExpression: UnionExpression): Expression;
    VisitUpdate(updateExpression: UpdateExpression): Expression;
    VisitValues(valuesExpression: ValuesExpression): Expression;
}


export const QuerySqlGenerator: {
    new(dependencies: QuerySqlGeneratorDependencies): QuerySqlGenerator;
};


export type QuerySqlGenerator = QuerySqlGenerator$instance;

export interface QuerySqlGeneratorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QuerySqlGeneratorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    RelationalCommandBuilderFactory: IRelationalCommandBuilderFactory;
    SqlGenerationHelper: ISqlGenerationHelper;
    _Clone_$(): QuerySqlGeneratorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: QuerySqlGeneratorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const QuerySqlGeneratorDependencies: {
    new(relationalCommandBuilderFactory: IRelationalCommandBuilderFactory, sqlGenerationHelper: ISqlGenerationHelper): QuerySqlGeneratorDependencies;
};


export type QuerySqlGeneratorDependencies = QuerySqlGeneratorDependencies$instance;

export interface QueryTranslationPostprocessor$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryTranslationPostprocessor: never;

    readonly Dependencies: QueryTranslationPostprocessorDependencies;
    readonly QueryCompilationContext: QueryCompilationContext;
    Process(query: Expression): Expression;
}


export const QueryTranslationPostprocessor: {
    new(dependencies: QueryTranslationPostprocessorDependencies, queryCompilationContext: QueryCompilationContext): QueryTranslationPostprocessor;
};


export type QueryTranslationPostprocessor = QueryTranslationPostprocessor$instance;

export interface QueryTranslationPostprocessorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryTranslationPostprocessorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


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


export type QueryTranslationPostprocessorDependencies = QueryTranslationPostprocessorDependencies$instance;

export interface QueryTranslationPreprocessor$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryTranslationPreprocessor: never;

    readonly Dependencies: QueryTranslationPreprocessorDependencies;
    readonly IsEfConstantSupported: boolean;
    readonly QueryCompilationContext: QueryCompilationContext;
    NormalizeQueryableMethod(expression: Expression): Expression;
    Process(query: Expression): Expression;
    ProcessQueryRoots(expression: Expression): Expression;
}


export const QueryTranslationPreprocessor: {
    new(dependencies: QueryTranslationPreprocessorDependencies, queryCompilationContext: QueryCompilationContext): QueryTranslationPreprocessor;
};


export type QueryTranslationPreprocessor = QueryTranslationPreprocessor$instance;

export interface QueryTranslationPreprocessorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_QueryTranslationPreprocessorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    EvaluatableExpressionFilter: IEvaluatableExpressionFilter;
    NavigationExpansionExtensibilityHelper: INavigationExpansionExtensibilityHelper;
    TypeMappingSource: ITypeMappingSource;
    _Clone_$(): QueryTranslationPreprocessorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: QueryTranslationPreprocessorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const QueryTranslationPreprocessorDependencies: {
    new(typeMappingSource: ITypeMappingSource, evaluatableExpressionFilter: IEvaluatableExpressionFilter, navigationExpansionExtensibilityHelper: INavigationExpansionExtensibilityHelper): QueryTranslationPreprocessorDependencies;
};


export type QueryTranslationPreprocessorDependencies = QueryTranslationPreprocessorDependencies$instance;

export interface RelationalAggregateMethodCallTranslatorProvider$instance extends IAggregateMethodCallTranslatorProvider$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalAggregateMethodCallTranslatorProvider: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IAggregateMethodCallTranslatorProvider: never;

    readonly Dependencies: RelationalAggregateMethodCallTranslatorProviderDependencies;
    AddTranslators(translators: IEnumerable_1<IAggregateMethodCallTranslator>): void;
    Translate(model: IModel, method: MethodInfo, source: EnumerableExpression, arguments: IReadOnlyList_1<SqlExpression>, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export const RelationalAggregateMethodCallTranslatorProvider: {
    new(dependencies: RelationalAggregateMethodCallTranslatorProviderDependencies): RelationalAggregateMethodCallTranslatorProvider;
};


export interface __RelationalAggregateMethodCallTranslatorProvider$views {
    As_IAggregateMethodCallTranslatorProvider(): IAggregateMethodCallTranslatorProvider$instance;
}

export type RelationalAggregateMethodCallTranslatorProvider = RelationalAggregateMethodCallTranslatorProvider$instance & __RelationalAggregateMethodCallTranslatorProvider$views;


export interface RelationalAggregateMethodCallTranslatorProviderDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalAggregateMethodCallTranslatorProviderDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Plugins: IEnumerable_1<IAggregateMethodCallTranslatorPlugin>;
    RelationalTypeMappingSource: IRelationalTypeMappingSource;
    SqlExpressionFactory: ISqlExpressionFactory;
    _Clone_$(): RelationalAggregateMethodCallTranslatorProviderDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalAggregateMethodCallTranslatorProviderDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalAggregateMethodCallTranslatorProviderDependencies: {
    new(sqlExpressionFactory: ISqlExpressionFactory, plugins: IEnumerable_1<IAggregateMethodCallTranslatorPlugin>, typeMappingSource: IRelationalTypeMappingSource): RelationalAggregateMethodCallTranslatorProviderDependencies;
};


export type RelationalAggregateMethodCallTranslatorProviderDependencies = RelationalAggregateMethodCallTranslatorProviderDependencies$instance;

export interface RelationalCollectionShaperExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalCollectionShaperExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly ElementType: Type;
    readonly InnerShaper: Expression;
    readonly Navigation: INavigationBase | null;
    readonly NodeType: ExpressionType;
    readonly OuterIdentifier: Expression;
    readonly OuterIdentifierValueComparers: IReadOnlyList_1<ValueComparer>;
    readonly ParentIdentifier: Expression;
    readonly ParentIdentifierValueComparers: IReadOnlyList_1<ValueComparer>;
    readonly SelfIdentifier: Expression;
    readonly SelfIdentifierValueComparers: IReadOnlyList_1<ValueComparer>;
    readonly Type: Type;
    Update(parentIdentifier: Expression, outerIdentifier: Expression, selfIdentifier: Expression, innerShaper: Expression): RelationalCollectionShaperExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const RelationalCollectionShaperExpression: {
    new(parentIdentifier: Expression, outerIdentifier: Expression, selfIdentifier: Expression, parentIdentifierValueComparers: IReadOnlyList_1<ValueComparer>, outerIdentifierValueComparers: IReadOnlyList_1<ValueComparer>, selfIdentifierValueComparers: IReadOnlyList_1<ValueComparer>, innerShaper: Expression, navigation: INavigationBase | null, elementType: Type): RelationalCollectionShaperExpression;
};


export interface __RelationalCollectionShaperExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type RelationalCollectionShaperExpression = RelationalCollectionShaperExpression$instance & __RelationalCollectionShaperExpression$views;


export interface RelationalCompiledQueryCacheKeyGenerator$instance extends CompiledQueryCacheKeyGenerator$instance, ICompiledQueryCacheKeyGenerator$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalCompiledQueryCacheKeyGenerator: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ICompiledQueryCacheKeyGenerator: never;

    readonly RelationalDependencies: RelationalCompiledQueryCacheKeyGeneratorDependencies;
    GenerateCacheKey(query: Expression, async: boolean): unknown;
}


export const RelationalCompiledQueryCacheKeyGenerator: {
    new(dependencies: CompiledQueryCacheKeyGeneratorDependencies, relationalDependencies: RelationalCompiledQueryCacheKeyGeneratorDependencies): RelationalCompiledQueryCacheKeyGenerator;
};


export interface __RelationalCompiledQueryCacheKeyGenerator$views {
    As_ICompiledQueryCacheKeyGenerator(): ICompiledQueryCacheKeyGenerator$instance;
}

export type RelationalCompiledQueryCacheKeyGenerator = RelationalCompiledQueryCacheKeyGenerator$instance & __RelationalCompiledQueryCacheKeyGenerator$views;


export interface RelationalCompiledQueryCacheKeyGenerator_RelationalCompiledQueryCacheKey$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalCompiledQueryCacheKeyGenerator_RelationalCompiledQueryCacheKey: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalCompiledQueryCacheKeyGenerator_RelationalCompiledQueryCacheKey): boolean;
    GetHashCode(): int;
}


export const RelationalCompiledQueryCacheKeyGenerator_RelationalCompiledQueryCacheKey: {
    new(compiledQueryCacheKey: CompiledQueryCacheKeyGenerator_CompiledQueryCacheKey, useRelationalNulls: boolean, querySplittingBehavior: Nullable_1<QuerySplittingBehavior>, shouldBuffer: boolean): RelationalCompiledQueryCacheKeyGenerator_RelationalCompiledQueryCacheKey;
};


export type RelationalCompiledQueryCacheKeyGenerator_RelationalCompiledQueryCacheKey = RelationalCompiledQueryCacheKeyGenerator_RelationalCompiledQueryCacheKey$instance;

export interface RelationalCompiledQueryCacheKeyGeneratorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalCompiledQueryCacheKeyGeneratorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


export const RelationalCompiledQueryCacheKeyGeneratorDependencies: {
    new(contextOptions: IDbContextOptions): RelationalCompiledQueryCacheKeyGeneratorDependencies;
};


export type RelationalCompiledQueryCacheKeyGeneratorDependencies = RelationalCompiledQueryCacheKeyGeneratorDependencies$instance;

export interface RelationalEvaluatableExpressionFilter$instance extends EvaluatableExpressionFilter$instance, IEvaluatableExpressionFilter$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalEvaluatableExpressionFilter: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IEvaluatableExpressionFilter: never;

    readonly RelationalDependencies: RelationalEvaluatableExpressionFilterDependencies;
    IsEvaluatableExpression(expression: Expression, model: IModel): boolean;
}


export const RelationalEvaluatableExpressionFilter: {
    new(dependencies: EvaluatableExpressionFilterDependencies, relationalDependencies: RelationalEvaluatableExpressionFilterDependencies): RelationalEvaluatableExpressionFilter;
};


export interface __RelationalEvaluatableExpressionFilter$views {
    As_IEvaluatableExpressionFilter(): IEvaluatableExpressionFilter$instance;
}

export type RelationalEvaluatableExpressionFilter = RelationalEvaluatableExpressionFilter$instance & __RelationalEvaluatableExpressionFilter$views;


export interface RelationalEvaluatableExpressionFilterDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalEvaluatableExpressionFilterDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


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


export type RelationalEvaluatableExpressionFilterDependencies = RelationalEvaluatableExpressionFilterDependencies$instance;

export interface RelationalGroupByResultExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalGroupByResultExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly ElementShaper: Expression;
    readonly KeyIdentifier: Expression;
    readonly KeyIdentifierValueComparers: IReadOnlyList_1<ValueComparer>;
    readonly KeyShaper: Expression;
    readonly NodeType: ExpressionType;
    readonly Type: Type;
    Update(keyIdentifier: Expression, keyShaper: Expression, elementShaper: Expression): RelationalGroupByResultExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const RelationalGroupByResultExpression: {
    new(keyIdentifier: Expression, keyIdentifierValueComparers: IReadOnlyList_1<ValueComparer>, keyShaper: Expression, elementShaper: Expression): RelationalGroupByResultExpression;
};


export interface __RelationalGroupByResultExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type RelationalGroupByResultExpression = RelationalGroupByResultExpression$instance & __RelationalGroupByResultExpression$views;


export interface RelationalGroupByShaperExpression$instance extends GroupByShaperExpression$instance, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalGroupByShaperExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly ElementSelector: Expression;
    Print(expressionPrinter: ExpressionPrinter): void;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const RelationalGroupByShaperExpression: {
    new(keySelector: Expression, elementSelector: Expression, groupingEnumerable: ShapedQueryExpression): RelationalGroupByShaperExpression;
};


export interface __RelationalGroupByShaperExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type RelationalGroupByShaperExpression = RelationalGroupByShaperExpression$instance & __RelationalGroupByShaperExpression$views;


export interface RelationalLiftableConstantExpressionDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalLiftableConstantExpressionDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


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


export type RelationalLiftableConstantExpressionDependencies = RelationalLiftableConstantExpressionDependencies$instance;

export interface RelationalLiftableConstantFactory$instance extends LiftableConstantFactory$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalLiftableConstantFactory: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ILiftableConstantFactory: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IRelationalLiftableConstantFactory: never;

    readonly RelationalDependencies: RelationalLiftableConstantExpressionDependencies;
    CreateLiftableConstant(originalValue: unknown | null, resolverExpression: Expression_1<Func_2<RelationalMaterializerLiftableConstantContext, unknown>>, variableName: string, type: Type): LiftableConstantExpression;
    CreateLiftableConstant(originalValue: unknown | null, resolverExpression: Expression_1<Func_2<MaterializerLiftableConstantContext, unknown>>, variableName: string, type: Type): Expression;
}


export const RelationalLiftableConstantFactory: {
    new(dependencies: LiftableConstantExpressionDependencies, relationalDependencies: RelationalLiftableConstantExpressionDependencies): RelationalLiftableConstantFactory;
};


export interface __RelationalLiftableConstantFactory$views {
    As_ILiftableConstantFactory(): ILiftableConstantFactory$instance;
    As_IRelationalLiftableConstantFactory(): IRelationalLiftableConstantFactory$instance;
}

export type RelationalLiftableConstantFactory = RelationalLiftableConstantFactory$instance & __RelationalLiftableConstantFactory$views;


export interface RelationalLiftableConstantProcessor$instance extends LiftableConstantProcessor$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalLiftableConstantProcessor: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ILiftableConstantProcessor: never;

    InlineConstant(liftableConstant: LiftableConstantExpression): ConstantExpression;
}


export const RelationalLiftableConstantProcessor: {
    new(dependencies: ShapedQueryCompilingExpressionVisitorDependencies, relationalDependencies: RelationalShapedQueryCompilingExpressionVisitorDependencies, commandBuilderDependencies: RelationalCommandBuilderDependencies): RelationalLiftableConstantProcessor;
};


export interface __RelationalLiftableConstantProcessor$views {
    As_ILiftableConstantProcessor(): ILiftableConstantProcessor$instance;
}

export type RelationalLiftableConstantProcessor = RelationalLiftableConstantProcessor$instance & __RelationalLiftableConstantProcessor$views;


export interface RelationalMaterializerLiftableConstantContext$instance extends MaterializerLiftableConstantContext {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalMaterializerLiftableConstantContext: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    CommandBuilderDependencies: RelationalCommandBuilderDependencies;
    readonly EqualityContract: Type;
    RelationalDependencies: RelationalShapedQueryCompilingExpressionVisitorDependencies;
    _Clone_$(): RelationalMaterializerLiftableConstantContext;
    _Clone_$(): MaterializerLiftableConstantContext;
    Deconstruct(Dependencies: ShapedQueryCompilingExpressionVisitorDependencies, RelationalDependencies: RelationalShapedQueryCompilingExpressionVisitorDependencies, CommandBuilderDependencies: RelationalCommandBuilderDependencies): void;
    Deconstruct(Dependencies: ShapedQueryCompilingExpressionVisitorDependencies): void;
    Equals(obj: unknown | null): boolean;
    Equals(other: MaterializerLiftableConstantContext | null): boolean;
    Equals(other: RelationalMaterializerLiftableConstantContext | null): boolean;
    GetHashCode(): int;
    PrintMembers(builder: StringBuilder): boolean;
    ToString(): string;
}


export const RelationalMaterializerLiftableConstantContext: {
    new(Dependencies: ShapedQueryCompilingExpressionVisitorDependencies, RelationalDependencies: RelationalShapedQueryCompilingExpressionVisitorDependencies, CommandBuilderDependencies: RelationalCommandBuilderDependencies): RelationalMaterializerLiftableConstantContext;
};


export type RelationalMaterializerLiftableConstantContext = RelationalMaterializerLiftableConstantContext$instance;

export interface RelationalMemberTranslatorProvider$instance extends IMemberTranslatorProvider$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalMemberTranslatorProvider: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IMemberTranslatorProvider: never;

    readonly Dependencies: RelationalMemberTranslatorProviderDependencies;
    AddTranslators(translators: IEnumerable_1<IMemberTranslator>): void;
    Translate(instance: SqlExpression | null, member: MemberInfo, returnType: Type, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export const RelationalMemberTranslatorProvider: {
    new(dependencies: RelationalMemberTranslatorProviderDependencies): RelationalMemberTranslatorProvider;
};


export interface __RelationalMemberTranslatorProvider$views {
    As_IMemberTranslatorProvider(): IMemberTranslatorProvider$instance;
}

export type RelationalMemberTranslatorProvider = RelationalMemberTranslatorProvider$instance & __RelationalMemberTranslatorProvider$views;


export interface RelationalMemberTranslatorProviderDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalMemberTranslatorProviderDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Plugins: IEnumerable_1<IMemberTranslatorPlugin>;
    SqlExpressionFactory: ISqlExpressionFactory;
    _Clone_$(): RelationalMemberTranslatorProviderDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalMemberTranslatorProviderDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalMemberTranslatorProviderDependencies: {
    new(sqlExpressionFactory: ISqlExpressionFactory, plugins: IEnumerable_1<IMemberTranslatorPlugin>): RelationalMemberTranslatorProviderDependencies;
};


export type RelationalMemberTranslatorProviderDependencies = RelationalMemberTranslatorProviderDependencies$instance;

export interface RelationalMethodCallTranslatorProvider$instance extends IMethodCallTranslatorProvider$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalMethodCallTranslatorProvider: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IMethodCallTranslatorProvider: never;

    readonly Dependencies: RelationalMethodCallTranslatorProviderDependencies;
    AddTranslators(translators: IEnumerable_1<IMethodCallTranslator>): void;
    Translate(model: IModel, instance: SqlExpression | null, method: MethodInfo, arguments: IReadOnlyList_1<SqlExpression>, logger: IDiagnosticsLogger_1<DbLoggerCategory_Query>): SqlExpression | null;
}


export const RelationalMethodCallTranslatorProvider: {
    new(dependencies: RelationalMethodCallTranslatorProviderDependencies): RelationalMethodCallTranslatorProvider;
};


export interface __RelationalMethodCallTranslatorProvider$views {
    As_IMethodCallTranslatorProvider(): IMethodCallTranslatorProvider$instance;
}

export type RelationalMethodCallTranslatorProvider = RelationalMethodCallTranslatorProvider$instance & __RelationalMethodCallTranslatorProvider$views;


export interface RelationalMethodCallTranslatorProviderDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalMethodCallTranslatorProviderDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Plugins: IEnumerable_1<IMethodCallTranslatorPlugin>;
    RelationalTypeMappingSource: IRelationalTypeMappingSource;
    SqlExpressionFactory: ISqlExpressionFactory;
    _Clone_$(): RelationalMethodCallTranslatorProviderDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalMethodCallTranslatorProviderDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalMethodCallTranslatorProviderDependencies: {
    new(sqlExpressionFactory: ISqlExpressionFactory, plugins: IEnumerable_1<IMethodCallTranslatorPlugin>, typeMappingSource: IRelationalTypeMappingSource): RelationalMethodCallTranslatorProviderDependencies;
};


export type RelationalMethodCallTranslatorProviderDependencies = RelationalMethodCallTranslatorProviderDependencies$instance;

export interface RelationalParameterBasedSqlProcessor$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalParameterBasedSqlProcessor: never;

    readonly Dependencies: RelationalParameterBasedSqlProcessorDependencies;
    readonly Parameters: RelationalParameterBasedSqlProcessorParameters;
    ExpandFromSqlParameter(queryExpression: Expression, Decorator: ParametersCacheDecorator): Expression;
    Optimize(queryExpression: Expression, parametersValues: IReadOnlyDictionary_2<System_Internal.String, unknown | null>, canCache: boolean): Expression;
    Process(queryExpression: Expression, parameters: Dictionary_2<System_Internal.String, unknown | null>, canCache: boolean): Expression;
    Process(queryExpression: Expression, parametersDecorator: ParametersCacheDecorator): Expression;
    ProcessSqlNullability(queryExpression: Expression, Decorator: ParametersCacheDecorator): Expression;
}


export const RelationalParameterBasedSqlProcessor: {
    new(dependencies: RelationalParameterBasedSqlProcessorDependencies, parameters: RelationalParameterBasedSqlProcessorParameters): RelationalParameterBasedSqlProcessor;
};


export type RelationalParameterBasedSqlProcessor = RelationalParameterBasedSqlProcessor$instance;

export interface RelationalParameterBasedSqlProcessorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalParameterBasedSqlProcessorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    ParameterNameGeneratorFactory: IParameterNameGeneratorFactory;
    SqlExpressionFactory: ISqlExpressionFactory;
    SqlGenerationHelper: ISqlGenerationHelper;
    TypeMappingSource: IRelationalTypeMappingSource;
    _Clone_$(): RelationalParameterBasedSqlProcessorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalParameterBasedSqlProcessorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalParameterBasedSqlProcessorDependencies: {
    new(sqlExpressionFactory: ISqlExpressionFactory, typeMappingSource: IRelationalTypeMappingSource, sqlGenerationHelper: ISqlGenerationHelper, parameterNameGeneratorFactory: IParameterNameGeneratorFactory): RelationalParameterBasedSqlProcessorDependencies;
};


export type RelationalParameterBasedSqlProcessorDependencies = RelationalParameterBasedSqlProcessorDependencies$instance;

export interface RelationalParameterBasedSqlProcessorParameters$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalParameterBasedSqlProcessorParameters: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    CollectionParameterTranslationMode: ParameterTranslationMode;
    UseRelationalNulls: boolean;
    _Clone_$(): RelationalParameterBasedSqlProcessorParameters;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalParameterBasedSqlProcessorParameters | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalParameterBasedSqlProcessorParameters: {
    new(useRelationalNulls: boolean, collectionParameterTranslationMode: ParameterTranslationMode): RelationalParameterBasedSqlProcessorParameters;
};


export type RelationalParameterBasedSqlProcessorParameters = RelationalParameterBasedSqlProcessorParameters$instance;

export interface RelationalQueryableMethodTranslatingExpressionVisitor$instance extends QueryableMethodTranslatingExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryableMethodTranslatingExpressionVisitor: never;

    readonly RelationalDependencies: RelationalQueryableMethodTranslatingExpressionVisitorDependencies;
    CreateSelect(entityType: IEntityType): SelectExpression;
    CreateSelect(jsonQueryExpression: JsonQueryExpression, tableExpressionBase: TableExpressionBase, identifierColumnName: string, identifierColumnType: Type, identifierColumnTypeMapping: RelationalTypeMapping): SelectExpression;
    CreateShapedQueryExpression(entityType: IEntityType): ShapedQueryExpression;
    CreateSubqueryVisitor(): QueryableMethodTranslatingExpressionVisitor;
    GenerateJsonPartialUpdateSetter(target: Expression, value: SqlExpression, existingSetterValue: SqlExpression | null): SqlExpression | null;
    IsNaturallyOrdered(selectExpression: SelectExpression): boolean;
    IsOrdered(selectExpression: SelectExpression): boolean;
    IsValidSelectExpressionForExecuteDelete(selectExpression: SelectExpression): boolean;
    IsValidSelectExpressionForExecuteDelete(selectExpression: SelectExpression, shaper: StructuralTypeShaperExpression, tableExpression: TableExpression | null): boolean;
    IsValidSelectExpressionForExecuteUpdate(selectExpression: SelectExpression, targetTable: TableExpressionBase, tableExpression: TableExpression | null): boolean;
    TransformJsonQueryToTable(jsonQueryExpression: JsonQueryExpression): ShapedQueryExpression | null;
    TranslateAll(source: ShapedQueryExpression, predicate: LambdaExpression): ShapedQueryExpression | null;
    TranslateAny(source: ShapedQueryExpression, predicate: LambdaExpression | null): ShapedQueryExpression | null;
    TranslateAverage(source: ShapedQueryExpression, selector: LambdaExpression | null, resultType: Type): ShapedQueryExpression | null;
    TranslateCast(source: ShapedQueryExpression, resultType: Type): ShapedQueryExpression;
    TranslateConcat(source1: ShapedQueryExpression, source2: ShapedQueryExpression): ShapedQueryExpression;
    TranslateContains(source: ShapedQueryExpression, item: Expression): ShapedQueryExpression | null;
    TranslateCount(source: ShapedQueryExpression, predicate: LambdaExpression | null): ShapedQueryExpression | null;
    TranslateDefaultIfEmpty(source: ShapedQueryExpression, defaultValue: Expression | null): ShapedQueryExpression | null;
    TranslateDistinct(source: ShapedQueryExpression): ShapedQueryExpression;
    TranslateElementAtOrDefault(source: ShapedQueryExpression, index: Expression, returnDefault: boolean): ShapedQueryExpression | null;
    TranslateExcept(source1: ShapedQueryExpression, source2: ShapedQueryExpression): ShapedQueryExpression;
    TranslateExecuteDelete(source: ShapedQueryExpression): DeleteExpression | null;
    TranslateExecuteDelete(source: ShapedQueryExpression): Expression | null;
    TranslateExecuteUpdate(source: ShapedQueryExpression, setters: IReadOnlyList_1<QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter>): UpdateExpression | null;
    TranslateExecuteUpdate(source: ShapedQueryExpression, setters: IReadOnlyList_1<QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter>): Expression | null;
    TranslateExpression(expression: Expression, applyDefaultTypeMapping?: boolean): SqlExpression | null;
    TranslateFirstOrDefault(source: ShapedQueryExpression, predicate: LambdaExpression | null, returnType: Type, returnDefault: boolean): ShapedQueryExpression | null;
    TranslateGroupBy(source: ShapedQueryExpression, keySelector: LambdaExpression, elementSelector: LambdaExpression | null, resultSelector: LambdaExpression | null): ShapedQueryExpression | null;
    TranslateGroupJoin(outer: ShapedQueryExpression, inner: ShapedQueryExpression, outerKeySelector: LambdaExpression, innerKeySelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateInlineQueryRoot(inlineQueryRootExpression: InlineQueryRootExpression): ShapedQueryExpression | null;
    TranslateIntersect(source1: ShapedQueryExpression, source2: ShapedQueryExpression): ShapedQueryExpression;
    TranslateJoin(outer: ShapedQueryExpression, inner: ShapedQueryExpression, outerKeySelector: LambdaExpression, innerKeySelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateLambdaExpression(shapedQueryExpression: ShapedQueryExpression, lambdaExpression: LambdaExpression): SqlExpression | null;
    TranslateLastOrDefault(source: ShapedQueryExpression, predicate: LambdaExpression | null, returnType: Type, returnDefault: boolean): ShapedQueryExpression | null;
    TranslateLeftJoin(outer: ShapedQueryExpression, inner: ShapedQueryExpression, outerKeySelector: LambdaExpression, innerKeySelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateLongCount(source: ShapedQueryExpression, predicate: LambdaExpression | null): ShapedQueryExpression | null;
    TranslateMax(source: ShapedQueryExpression, selector: LambdaExpression | null, resultType: Type): ShapedQueryExpression | null;
    TranslateMemberAccess(source: Expression, member: MemberIdentity): ShapedQueryExpression | null;
    TranslateMin(source: ShapedQueryExpression, selector: LambdaExpression | null, resultType: Type): ShapedQueryExpression | null;
    TranslateOfType(source: ShapedQueryExpression, resultType: Type): ShapedQueryExpression | null;
    TranslateOrderBy(source: ShapedQueryExpression, keySelector: LambdaExpression, ascending: boolean): ShapedQueryExpression | null;
    TranslateParameterQueryRoot(parameterQueryRootExpression: ParameterQueryRootExpression): ShapedQueryExpression | null;
    TranslatePrimitiveCollection(sqlExpression: SqlExpression, property: IProperty | null, tableAlias: string): ShapedQueryExpression | null;
    TranslateReverse(source: ShapedQueryExpression): ShapedQueryExpression | null;
    TranslateRightJoin(outer: ShapedQueryExpression, inner: ShapedQueryExpression, outerKeySelector: LambdaExpression, innerKeySelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateSelect(source: ShapedQueryExpression, selector: LambdaExpression): ShapedQueryExpression;
    TranslateSelectMany(source: ShapedQueryExpression, collectionSelector: LambdaExpression, resultSelector: LambdaExpression): ShapedQueryExpression | null;
    TranslateSelectMany(source: ShapedQueryExpression, selector: LambdaExpression): ShapedQueryExpression | null;
    TranslateSingleOrDefault(source: ShapedQueryExpression, predicate: LambdaExpression | null, returnType: Type, returnDefault: boolean): ShapedQueryExpression | null;
    TranslateSkip(source: ShapedQueryExpression, count: Expression): ShapedQueryExpression | null;
    TranslateSkipWhile(source: ShapedQueryExpression, predicate: LambdaExpression): ShapedQueryExpression | null;
    TranslateSum(source: ShapedQueryExpression, selector: LambdaExpression | null, resultType: Type): ShapedQueryExpression | null;
    TranslateTake(source: ShapedQueryExpression, count: Expression): ShapedQueryExpression | null;
    TranslateTakeWhile(source: ShapedQueryExpression, predicate: LambdaExpression): ShapedQueryExpression | null;
    TranslateThenBy(source: ShapedQueryExpression, keySelector: LambdaExpression, ascending: boolean): ShapedQueryExpression | null;
    TranslateUnion(source1: ShapedQueryExpression, source2: ShapedQueryExpression): ShapedQueryExpression;
    TranslateWhere(source: ShapedQueryExpression, predicate: LambdaExpression): ShapedQueryExpression | null;
    TrySerializeScalarToJson(target: JsonScalarExpression, value: SqlExpression, jsonValue: SqlExpression | null): boolean;
    TryTranslateSetters(source: ShapedQueryExpression, setters: IReadOnlyList_1<QueryableMethodTranslatingExpressionVisitor_ExecuteUpdateSetter>, columnSetters: IReadOnlyList_1<ColumnValueSetter> | null, targetTable: TableExpressionBase | null): boolean;
    VisitExtension(extensionExpression: Expression): Expression;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
}


export const RelationalQueryableMethodTranslatingExpressionVisitor: {
    new(dependencies: QueryableMethodTranslatingExpressionVisitorDependencies, relationalDependencies: RelationalQueryableMethodTranslatingExpressionVisitorDependencies, queryCompilationContext: RelationalQueryCompilationContext): RelationalQueryableMethodTranslatingExpressionVisitor;
    readonly ValuesOrderingColumnName: string;
    readonly ValuesValueColumnName: string;
};


export type RelationalQueryableMethodTranslatingExpressionVisitor = RelationalQueryableMethodTranslatingExpressionVisitor$instance;

export interface RelationalQueryableMethodTranslatingExpressionVisitor_RelationalInferredTypeMappingApplier$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryableMethodTranslatingExpressionVisitor_RelationalInferredTypeMappingApplier: never;

}


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


export type RelationalQueryableMethodTranslatingExpressionVisitor_RelationalInferredTypeMappingApplier = RelationalQueryableMethodTranslatingExpressionVisitor_RelationalInferredTypeMappingApplier$instance;

export interface RelationalQueryableMethodTranslatingExpressionVisitorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryableMethodTranslatingExpressionVisitorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Model: IModel;
    RelationalSqlTranslatingExpressionVisitorFactory: IRelationalSqlTranslatingExpressionVisitorFactory;
    SqlExpressionFactory: ISqlExpressionFactory;
    TypeMappingSource: IRelationalTypeMappingSource;
    _Clone_$(): RelationalQueryableMethodTranslatingExpressionVisitorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalQueryableMethodTranslatingExpressionVisitorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalQueryableMethodTranslatingExpressionVisitorDependencies: {
    new(relationalSqlTranslatingExpressionVisitorFactory: IRelationalSqlTranslatingExpressionVisitorFactory, sqlExpressionFactory: ISqlExpressionFactory, typeMappingSource: IRelationalTypeMappingSource, model: IModel): RelationalQueryableMethodTranslatingExpressionVisitorDependencies;
};


export type RelationalQueryableMethodTranslatingExpressionVisitorDependencies = RelationalQueryableMethodTranslatingExpressionVisitorDependencies$instance;

export interface RelationalQueryCompilationContext$instance extends QueryCompilationContext {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryCompilationContext: never;

    get QuerySplittingBehavior(): Nullable_1<QuerySplittingBehavior>;
    set QuerySplittingBehavior(value: Nullable_1<QuerySplittingBehavior> | QuerySplittingBehavior);
    readonly RelationalDependencies: RelationalQueryCompilationContextDependencies;
    readonly SqlAliasManager: SqlAliasManager;
}


export const RelationalQueryCompilationContext: {
    new(dependencies: QueryCompilationContextDependencies, relationalDependencies: RelationalQueryCompilationContextDependencies, async: boolean): RelationalQueryCompilationContext;
    new(dependencies: QueryCompilationContextDependencies, relationalDependencies: RelationalQueryCompilationContextDependencies, async: boolean, precompiling: boolean): RelationalQueryCompilationContext;
};


export type RelationalQueryCompilationContext = RelationalQueryCompilationContext$instance;

export interface RelationalQueryCompilationContextDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryCompilationContextDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


export const RelationalQueryCompilationContextDependencies: {
    new(sqlAliasManagerFactory: ISqlAliasManagerFactory): RelationalQueryCompilationContextDependencies;
};


export type RelationalQueryCompilationContextDependencies = RelationalQueryCompilationContextDependencies$instance;

export interface RelationalQueryContext$instance extends QueryContext {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryContext: never;

    readonly CommandLogger: IDiagnosticsLogger_1<DbLoggerCategory_Database_Command> | IRelationalCommandDiagnosticsLogger;
    readonly Connection: IRelationalConnection;
    readonly RelationalDependencies: RelationalQueryContextDependencies;
    readonly RelationalQueryStringFactory: IRelationalQueryStringFactory;
}


export const RelationalQueryContext: {
    new(dependencies: QueryContextDependencies, relationalDependencies: RelationalQueryContextDependencies): RelationalQueryContext;
};


export type RelationalQueryContext = RelationalQueryContext$instance;

export interface RelationalQueryContextDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryContextDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    RelationalConnection: IRelationalConnection;
    RelationalQueryStringFactory: IRelationalQueryStringFactory;
    _Clone_$(): RelationalQueryContextDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalQueryContextDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalQueryContextDependencies: {
    new(relationalConnection: IRelationalConnection, relationalQueryStringFactory: IRelationalQueryStringFactory): RelationalQueryContextDependencies;
};


export type RelationalQueryContextDependencies = RelationalQueryContextDependencies$instance;

export interface RelationalQueryRootProcessor$instance extends QueryRootProcessor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryRootProcessor: never;

    ShouldConvertToInlineQueryRoot(expression: Expression): boolean;
    ShouldConvertToParameterQueryRoot(queryParameterExpression: QueryParameterExpression): boolean;
    VisitExtension(node: Expression): Expression;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
}


export const RelationalQueryRootProcessor: {
    new(dependencies: QueryTranslationPreprocessorDependencies, relationalDependencies: RelationalQueryTranslationPreprocessorDependencies, queryCompilationContext: QueryCompilationContext): RelationalQueryRootProcessor;
};


export type RelationalQueryRootProcessor = RelationalQueryRootProcessor$instance;

export interface RelationalQueryTranslationPostprocessor$instance extends QueryTranslationPostprocessor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryTranslationPostprocessor: never;

    readonly RelationalDependencies: RelationalQueryTranslationPostprocessorDependencies;
    readonly RelationalQueryCompilationContext: RelationalQueryCompilationContext;
    Process(query: Expression): Expression;
    ProcessTypeMappings(expression: Expression): Expression;
    Prune(query: Expression): Expression;
}


export const RelationalQueryTranslationPostprocessor: {
    new(dependencies: QueryTranslationPostprocessorDependencies, relationalDependencies: RelationalQueryTranslationPostprocessorDependencies, queryCompilationContext: RelationalQueryCompilationContext): RelationalQueryTranslationPostprocessor;
};


export type RelationalQueryTranslationPostprocessor = RelationalQueryTranslationPostprocessor$instance;

export interface RelationalQueryTranslationPostprocessorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryTranslationPostprocessorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    SqlExpressionFactory: ISqlExpressionFactory;
    TypeMappingSource: IRelationalTypeMappingSource;
    _Clone_$(): RelationalQueryTranslationPostprocessorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalQueryTranslationPostprocessorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalQueryTranslationPostprocessorDependencies: {
    new(sqlExpressionFactory: ISqlExpressionFactory, typeMappingSource: IRelationalTypeMappingSource): RelationalQueryTranslationPostprocessorDependencies;
};


export type RelationalQueryTranslationPostprocessorDependencies = RelationalQueryTranslationPostprocessorDependencies$instance;

export interface RelationalQueryTranslationPreprocessor$instance extends QueryTranslationPreprocessor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryTranslationPreprocessor: never;

    readonly IsEfConstantSupported: boolean;
    readonly RelationalDependencies: RelationalQueryTranslationPreprocessorDependencies;
    NormalizeQueryableMethod(expression: Expression): Expression;
    ProcessQueryRoots(expression: Expression): Expression;
}


export const RelationalQueryTranslationPreprocessor: {
    new(dependencies: QueryTranslationPreprocessorDependencies, relationalDependencies: RelationalQueryTranslationPreprocessorDependencies, queryCompilationContext: QueryCompilationContext): RelationalQueryTranslationPreprocessor;
};


export type RelationalQueryTranslationPreprocessor = RelationalQueryTranslationPreprocessor$instance;

export interface RelationalQueryTranslationPreprocessorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalQueryTranslationPreprocessorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

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


export const RelationalQueryTranslationPreprocessorDependencies: {
    new(relationalTypeMappingSource: IRelationalTypeMappingSource): RelationalQueryTranslationPreprocessorDependencies;
};


export type RelationalQueryTranslationPreprocessorDependencies = RelationalQueryTranslationPreprocessorDependencies$instance;

export interface RelationalShapedQueryCompilingExpressionVisitor$instance extends ShapedQueryCompilingExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalShapedQueryCompilingExpressionVisitor: never;

    readonly MaxNullableParametersForPregeneratedSql: int;
    readonly RelationalDependencies: RelationalShapedQueryCompilingExpressionVisitorDependencies;
    AddStructuralTypeInitialization(shaper: StructuralTypeShaperExpression, instanceVariable: ParameterExpression, variables: List_1<ParameterExpression>, expressions: List_1<Expression>): void;
    VisitExtension(extensionExpression: Expression): Expression;
    VisitShapedQuery(shapedQueryExpression: ShapedQueryExpression): Expression;
}


export const RelationalShapedQueryCompilingExpressionVisitor: {
    new(dependencies: ShapedQueryCompilingExpressionVisitorDependencies, relationalDependencies: RelationalShapedQueryCompilingExpressionVisitorDependencies, queryCompilationContext: QueryCompilationContext): RelationalShapedQueryCompilingExpressionVisitor;
    NonQueryResult(relationalQueryContext: RelationalQueryContext, relationalCommandResolver: RelationalCommandResolver, contextType: Type, commandSource: CommandSource, threadSafetyChecksEnabled: boolean): int;
    NonQueryResultAsync(relationalQueryContext: RelationalQueryContext, relationalCommandResolver: RelationalCommandResolver, contextType: Type, commandSource: CommandSource, threadSafetyChecksEnabled: boolean): Task_1<System_Internal.Int32>;
};


export type RelationalShapedQueryCompilingExpressionVisitor = RelationalShapedQueryCompilingExpressionVisitor$instance;

export interface RelationalShapedQueryCompilingExpressionVisitor_ShaperProcessingExpressionVisitor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalShapedQueryCompilingExpressionVisitor_ShaperProcessingExpressionVisitor: never;

    ProcessRelationalGroupingResult(relationalGroupByResultExpression: RelationalGroupByResultExpression, relationalCommandResolver: Expression, readerColumns: IReadOnlyList_1<ReaderColumn | null> | null, keySelector: LambdaExpression, keyIdentifier: LambdaExpression, relatedDataLoaders: LambdaExpression | null, collectionId: int): LambdaExpression;
    ProcessShaper(shaperExpression: Expression, relationalCommandResolver: Expression, readerColumns: IReadOnlyList_1<ReaderColumn | null> | null, relatedDataLoaders: LambdaExpression | null, collectionId: int): LambdaExpression;
    VisitBinary(binaryExpression: BinaryExpression): Expression;
    VisitExtension(extensionExpression: Expression): Expression;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
}


export const RelationalShapedQueryCompilingExpressionVisitor_ShaperProcessingExpressionVisitor: {
    new(parentVisitor: RelationalShapedQueryCompilingExpressionVisitor, selectExpression: SelectExpression, tags: ISet_1<System_Internal.String>, splitQuery: boolean, indexMap: boolean): RelationalShapedQueryCompilingExpressionVisitor_ShaperProcessingExpressionVisitor;
    readonly GetFieldValueMethod: MethodInfo;
    Any(source: IEnumerable): boolean;
    IncludeJsonEntityCollection<TIncludingEntity extends (object | null), TIncludedCollectionElement extends (object | null)>(queryContext: QueryContext, keyPropertyValues: unknown[] | null, jsonReaderData: JsonReaderData | null, entity: TIncludingEntity, innerShaper: Func_4<QueryContext, unknown[] | null, JsonReaderData, TIncludedCollectionElement>, getOrCreateCollectionObject: Action_1<TIncludingEntity>, fixup: Action_2<TIncludingEntity, TIncludedCollectionElement>, performFixup: boolean): void;
    IncludeJsonEntityReference<TStructural extends unknown, TRelatedStructural extends unknown>(queryContext: QueryContext, keyPropertyValues: unknown[] | null, jsonReaderData: JsonReaderData | null, structuralType: TStructural, innerShaper: Func_4<QueryContext, unknown[] | null, JsonReaderData, TRelatedStructural>, fixup: Action_2<TStructural, TRelatedStructural>, performFixup: boolean): void;
    IncludeReference<TEntity extends (object | null), TIncludingEntity extends (object | null), TIncludedEntity extends (object | null)>(queryContext: QueryContext, entity: TEntity, relatedEntity: TIncludedEntity | null, navigation: INavigationBase, inverseNavigation: INavigationBase | null, fixup: Action_2<TIncludingEntity, TIncludedEntity>, trackingQuery: boolean): void;
    InitializeCollection<TElement extends unknown, TCollection extends (object | null)>(collectionId: int, queryContext: QueryContext, dbDataReader: DbDataReader, resultCoordinator: SingleQueryResultCoordinator, parentIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, outerIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, clrCollectionAccessor: IClrCollectionAccessor | null): TCollection;
    InitializeIncludeCollection<TParent extends (object | null), TNavigationEntity extends (object | null)>(collectionId: int, queryContext: QueryContext, dbDataReader: DbDataReader, resultCoordinator: SingleQueryResultCoordinator, entity: TParent, parentIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, outerIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, navigation: INavigationBase, clrCollectionAccessor: IClrCollectionAccessor | null, trackingQuery: boolean, setLoaded: boolean): void;
    InitializeSplitCollection<TElement extends unknown, TCollection extends (object | null)>(collectionId: int, queryContext: QueryContext, parentDataReader: DbDataReader, resultCoordinator: SplitQueryResultCoordinator, parentIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, clrCollectionAccessor: IClrCollectionAccessor | null): TCollection;
    InitializeSplitIncludeCollection<TParent extends (object | null), TNavigationEntity extends (object | null)>(collectionId: int, queryContext: QueryContext, parentDataReader: DbDataReader, resultCoordinator: SplitQueryResultCoordinator, entity: TParent, parentIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, navigation: INavigationBase, clrCollectionAccessor: IClrCollectionAccessor | null, trackingQuery: boolean, setLoaded: boolean): void;
    InverseCollectionFixup<TCollectionElement extends unknown, TEntity extends unknown>(collection: ICollection_1<TCollectionElement>, entity: TEntity, elementFixup: Action_2<TCollectionElement, TEntity>): void;
    MaterializeJsonEntityCollection<TEntity extends (object | null), TResult extends unknown>(queryContext: QueryContext, keyPropertyValues: unknown[] | null, jsonReaderData: JsonReaderData | null, structuralProperty: IPropertyBase, innerShaper: Func_4<QueryContext, unknown[] | null, JsonReaderData, TEntity>): TResult | null;
    MaterializeJsonNullableValueStructuralType<TStructural extends NonNullable<unknown>>(queryContext: QueryContext, keyPropertyValues: unknown[] | null, jsonReaderData: JsonReaderData | null, nullable: boolean, shaper: Func_4<QueryContext, unknown[], JsonReaderData, TStructural>): Nullable_1<TStructural>;
    MaterializeJsonStructuralType<TStructural extends unknown>(queryContext: QueryContext, keyPropertyValues: unknown[] | null, jsonReaderData: JsonReaderData | null, nullable: boolean, shaper: Func_4<QueryContext, unknown[] | null, JsonReaderData, TStructural>): TStructural | null;
    PopulateCollection<TCollection extends (object | null), TElement extends unknown, TRelatedEntity extends unknown>(collectionId: int, queryContext: QueryContext, dbDataReader: DbDataReader, resultCoordinator: SingleQueryResultCoordinator, parentIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, outerIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, selfIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, parentIdentifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, outerIdentifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, selfIdentifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, innerShaper: Func_5<QueryContext, DbDataReader, ResultContext, SingleQueryResultCoordinator, TRelatedEntity>): void;
    PopulateIncludeCollection<TIncludingEntity extends (object | null), TIncludedEntity extends (object | null)>(collectionId: int, queryContext: QueryContext, dbDataReader: DbDataReader, resultCoordinator: SingleQueryResultCoordinator, parentIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, outerIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, selfIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, parentIdentifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, outerIdentifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, selfIdentifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, innerShaper: Func_5<QueryContext, DbDataReader, ResultContext, SingleQueryResultCoordinator, TIncludedEntity>, inverseNavigation: INavigationBase | null, fixup: Action_2<TIncludingEntity, TIncludedEntity>, trackingQuery: boolean): void;
    PopulateSplitCollection<TCollection extends (object | null), TElement extends unknown, TRelatedEntity extends unknown>(collectionId: int, queryContext: RelationalQueryContext, executionStrategy: IExecutionStrategy, relationalCommandResolver: RelationalCommandResolver, readerColumns: IReadOnlyList_1<ReaderColumn | null> | null, detailedErrorsEnabled: boolean, resultCoordinator: SplitQueryResultCoordinator, childIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, identifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, innerShaper: Func_5<QueryContext, DbDataReader, ResultContext, SplitQueryResultCoordinator, TRelatedEntity>, relatedDataLoaders: Action_3<QueryContext, IExecutionStrategy, SplitQueryResultCoordinator> | null): void;
    PopulateSplitCollectionAsync<TCollection extends (object | null), TElement extends unknown, TRelatedEntity extends unknown>(collectionId: int, queryContext: RelationalQueryContext, executionStrategy: IExecutionStrategy, relationalCommandResolver: RelationalCommandResolver, readerColumns: IReadOnlyList_1<ReaderColumn | null> | null, detailedErrorsEnabled: boolean, resultCoordinator: SplitQueryResultCoordinator, childIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, identifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, innerShaper: Func_5<QueryContext, DbDataReader, ResultContext, SplitQueryResultCoordinator, TRelatedEntity>, relatedDataLoaders: Func_4<QueryContext, IExecutionStrategy, SplitQueryResultCoordinator, Task> | null): Task;
    PopulateSplitIncludeCollection<TIncludingEntity extends (object | null), TIncludedEntity extends (object | null)>(collectionId: int, queryContext: RelationalQueryContext, executionStrategy: IExecutionStrategy, relationalCommandResolver: RelationalCommandResolver, readerColumns: IReadOnlyList_1<ReaderColumn | null> | null, detailedErrorsEnabled: boolean, resultCoordinator: SplitQueryResultCoordinator, childIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, identifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, innerShaper: Func_5<QueryContext, DbDataReader, ResultContext, SplitQueryResultCoordinator, TIncludedEntity>, relatedDataLoaders: Action_3<QueryContext, IExecutionStrategy, SplitQueryResultCoordinator> | null, inverseNavigation: INavigationBase | null, fixup: Action_2<TIncludingEntity, TIncludedEntity>, trackingQuery: boolean): void;
    PopulateSplitIncludeCollectionAsync<TIncludingEntity extends (object | null), TIncludedEntity extends (object | null)>(collectionId: int, queryContext: RelationalQueryContext, executionStrategy: IExecutionStrategy, relationalCommandResolver: RelationalCommandResolver, readerColumns: IReadOnlyList_1<ReaderColumn | null> | null, detailedErrorsEnabled: boolean, resultCoordinator: SplitQueryResultCoordinator, childIdentifier: Func_3<QueryContext, DbDataReader, unknown[]>, identifierValueComparers: IReadOnlyList_1<Func_3<unknown, unknown, System_Internal.Boolean>>, innerShaper: Func_5<QueryContext, DbDataReader, ResultContext, SplitQueryResultCoordinator, TIncludedEntity>, relatedDataLoaders: Func_4<QueryContext, IExecutionStrategy, SplitQueryResultCoordinator, Task> | null, inverseNavigation: INavigationBase | null, fixup: Action_2<TIncludingEntity, TIncludedEntity>, trackingQuery: boolean): Task;
    TaskAwaiter(taskFactories: Func_1<Task>[]): Task;
    ThrowReadValueException<TValue extends unknown>(exception: Exception, value: unknown | null, expectedType: Type, property?: IPropertyBase | null): TValue;
};


export type RelationalShapedQueryCompilingExpressionVisitor_ShaperProcessingExpressionVisitor = RelationalShapedQueryCompilingExpressionVisitor_ShaperProcessingExpressionVisitor$instance;

export interface RelationalShapedQueryCompilingExpressionVisitorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalShapedQueryCompilingExpressionVisitorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    QuerySqlGeneratorFactory: IQuerySqlGeneratorFactory;
    RelationalLiftableConstantFactory: IRelationalLiftableConstantFactory;
    RelationalParameterBasedSqlProcessorFactory: IRelationalParameterBasedSqlProcessorFactory;
    _Clone_$(): RelationalShapedQueryCompilingExpressionVisitorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalShapedQueryCompilingExpressionVisitorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalShapedQueryCompilingExpressionVisitorDependencies: {
    new(querySqlGeneratorFactory: IQuerySqlGeneratorFactory, relationalParameterBasedSqlProcessorFactory: IRelationalParameterBasedSqlProcessorFactory, relationalLiftableConstantFactory: IRelationalLiftableConstantFactory): RelationalShapedQueryCompilingExpressionVisitorDependencies;
};


export type RelationalShapedQueryCompilingExpressionVisitorDependencies = RelationalShapedQueryCompilingExpressionVisitorDependencies$instance;

export interface RelationalSplitCollectionShaperExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalSplitCollectionShaperExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly ChildIdentifier: Expression;
    readonly ElementType: Type;
    readonly IdentifierValueComparers: IReadOnlyList_1<ValueComparer>;
    readonly InnerShaper: Expression;
    readonly Navigation: INavigationBase | null;
    readonly NodeType: ExpressionType;
    readonly ParentIdentifier: Expression;
    readonly SelectExpression: SelectExpression;
    readonly Type: Type;
    Update(parentIdentifier: Expression, childIdentifier: Expression, selectExpression: SelectExpression, innerShaper: Expression): RelationalSplitCollectionShaperExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const RelationalSplitCollectionShaperExpression: {
    new(parentIdentifier: Expression, childIdentifier: Expression, identifierValueComparers: IReadOnlyList_1<ValueComparer>, selectExpression: SelectExpression, innerShaper: Expression, navigation: INavigationBase | null, elementType: Type): RelationalSplitCollectionShaperExpression;
};


export interface __RelationalSplitCollectionShaperExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type RelationalSplitCollectionShaperExpression = RelationalSplitCollectionShaperExpression$instance & __RelationalSplitCollectionShaperExpression$views;


export interface RelationalSqlTranslatingExpressionVisitor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalSqlTranslatingExpressionVisitor: never;

    readonly Dependencies: RelationalSqlTranslatingExpressionVisitorDependencies;
    get TranslationErrorDetails(): string | null;
    set TranslationErrorDetails(value: string | null);
    AddTranslationErrorDetails(details: string): void;
    GenerateGreatest(expressions: IReadOnlyList_1<SqlExpression>, resultType: Type): SqlExpression | null;
    GenerateLeast(expressions: IReadOnlyList_1<SqlExpression>, resultType: Type): SqlExpression | null;
    Translate(expression: Expression, applyDefaultTypeMapping?: boolean): SqlExpression | null;
    TranslateProjection(expression: Expression, applyDefaultTypeMapping?: boolean): Expression | null;
    TryBindMember(source: Expression | null, member: MemberIdentity, expression: Expression | null, property: IPropertyBase | null): boolean;
    TryTranslateAggregateMethodCall(methodCallExpression: MethodCallExpression, translation: SqlExpression | null): boolean;
    VisitBinary(binaryExpression: BinaryExpression): Expression;
    VisitConditional(conditionalExpression: ConditionalExpression): Expression;
    VisitConstant(constantExpression: ConstantExpression): Expression;
    VisitExtension(extensionExpression: Expression): Expression;
    VisitInvocation(invocationExpression: InvocationExpression): Expression;
    VisitLambda<T extends unknown>(lambdaExpression: Expression_1<T>): Expression;
    VisitListInit(listInitExpression: ListInitExpression): Expression;
    VisitMember(memberExpression: MemberExpression): Expression;
    VisitMemberInit(memberInitExpression: MemberInitExpression): Expression;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
    VisitNew(newExpression: NewExpression): Expression;
    VisitNewArray(newArrayExpression: NewArrayExpression): Expression;
    VisitParameter(parameterExpression: ParameterExpression): Expression;
    VisitTypeBinary(typeBinaryExpression: TypeBinaryExpression): Expression;
    VisitUnary(unaryExpression: UnaryExpression): Expression;
}


export const RelationalSqlTranslatingExpressionVisitor: {
    new(dependencies: RelationalSqlTranslatingExpressionVisitorDependencies, queryCompilationContext: QueryCompilationContext, queryableMethodTranslatingExpressionVisitor: QueryableMethodTranslatingExpressionVisitor): RelationalSqlTranslatingExpressionVisitor;
    ParameterListValueExtractor<TEntity extends unknown, TProperty extends unknown>(context: QueryContext, baseParameterName: string, property: IProperty): List_1<TProperty | null> | null;
    ParameterValueExtractor<T extends unknown>(context: QueryContext, baseParameterName: string, complexPropertyChain: List_1<IComplexProperty> | null, property: IProperty | null): T | null;
};


export type RelationalSqlTranslatingExpressionVisitor = RelationalSqlTranslatingExpressionVisitor$instance;

export interface RelationalSqlTranslatingExpressionVisitorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalSqlTranslatingExpressionVisitorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    readonly AggregateMethodCallTranslatorProvider: IAggregateMethodCallTranslatorProvider;
    MemberTranslatorProvider: IMemberTranslatorProvider;
    MethodCallTranslatorProvider: IMethodCallTranslatorProvider;
    Model: IModel;
    SqlExpressionFactory: ISqlExpressionFactory;
    TypeMappingSource: IRelationalTypeMappingSource;
    _Clone_$(): RelationalSqlTranslatingExpressionVisitorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: RelationalSqlTranslatingExpressionVisitorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const RelationalSqlTranslatingExpressionVisitorDependencies: {
    new(sqlExpressionFactory: ISqlExpressionFactory, model: IModel, typeMappingSource: IRelationalTypeMappingSource, memberTranslatorProvider: IMemberTranslatorProvider, methodCallTranslatorProvider: IMethodCallTranslatorProvider, aggregateMethodCallTranslatorProvider: IAggregateMethodCallTranslatorProvider): RelationalSqlTranslatingExpressionVisitorDependencies;
};


export type RelationalSqlTranslatingExpressionVisitorDependencies = RelationalSqlTranslatingExpressionVisitorDependencies$instance;

export interface RelationalSqlTranslatingExpressionVisitorFactory$instance extends IRelationalSqlTranslatingExpressionVisitorFactory$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalSqlTranslatingExpressionVisitorFactory: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IRelationalSqlTranslatingExpressionVisitorFactory: never;

    readonly Dependencies: RelationalSqlTranslatingExpressionVisitorDependencies;
    Create(queryCompilationContext: QueryCompilationContext, queryableMethodTranslatingExpressionVisitor: QueryableMethodTranslatingExpressionVisitor): RelationalSqlTranslatingExpressionVisitor;
}


export const RelationalSqlTranslatingExpressionVisitorFactory: {
    new(dependencies: RelationalSqlTranslatingExpressionVisitorDependencies): RelationalSqlTranslatingExpressionVisitorFactory;
};


export interface __RelationalSqlTranslatingExpressionVisitorFactory$views {
    As_IRelationalSqlTranslatingExpressionVisitorFactory(): IRelationalSqlTranslatingExpressionVisitorFactory$instance;
}

export type RelationalSqlTranslatingExpressionVisitorFactory = RelationalSqlTranslatingExpressionVisitorFactory$instance & __RelationalSqlTranslatingExpressionVisitorFactory$views;


export interface RelationalStructuralTypeShaperExpression$instance extends StructuralTypeShaperExpression$instance, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalStructuralTypeShaperExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    GenerateMaterializationCondition(type: ITypeBase, nullable: boolean): LambdaExpression;
    MakeClrTypeNonNullable(): RelationalStructuralTypeShaperExpression;
    MakeClrTypeNonNullable(): StructuralTypeShaperExpression;
    MakeClrTypeNullable(): RelationalStructuralTypeShaperExpression;
    MakeClrTypeNullable(): StructuralTypeShaperExpression;
    MakeNullable(nullable?: boolean): StructuralTypeShaperExpression;
    Update(valueBufferExpression: Expression): StructuralTypeShaperExpression;
    WithType(type: ITypeBase): StructuralTypeShaperExpression;
}


export const RelationalStructuralTypeShaperExpression: {
    new(structuralType: ITypeBase, valueBufferExpression: Expression, nullable: boolean): RelationalStructuralTypeShaperExpression;
};


export interface __RelationalStructuralTypeShaperExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type RelationalStructuralTypeShaperExpression = RelationalStructuralTypeShaperExpression$instance & __RelationalStructuralTypeShaperExpression$views;


export interface RelationalTypeMappingPostprocessor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_RelationalTypeMappingPostprocessor: never;

    readonly Dependencies: QueryTranslationPostprocessorDependencies;
    readonly QueryCompilationContext: RelationalQueryCompilationContext;
    readonly RelationalDependencies: RelationalQueryTranslationPostprocessorDependencies;
    ApplyTypeMappingsOnValuesExpression(valuesExpression: ValuesExpression): ValuesExpression;
    Process(expression: Expression): Expression;
    TryGetInferredTypeMapping(tableAlias: string, columnName: string, inferredTypeMapping: RelationalTypeMapping | null): boolean;
    VisitExtension(expression: Expression): Expression;
}


export const RelationalTypeMappingPostprocessor: {
    new(dependencies: QueryTranslationPostprocessorDependencies, relationalDependencies: RelationalQueryTranslationPostprocessorDependencies, queryCompilationContext: RelationalQueryCompilationContext): RelationalTypeMappingPostprocessor;
};


export type RelationalTypeMappingPostprocessor = RelationalTypeMappingPostprocessor$instance;

export interface ReplacingExpressionVisitor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ReplacingExpressionVisitor: never;

    Visit(expression: Expression | null): Expression | null;
    VisitMember(memberExpression: MemberExpression): Expression;
    VisitMethodCall(methodCallExpression: MethodCallExpression): Expression;
}


export const ReplacingExpressionVisitor: {
    new(originals: IReadOnlyList_1<Expression>, replacements: IReadOnlyList_1<Expression>): ReplacingExpressionVisitor;
    Replace(originals: IReadOnlyList_1<Expression>, replacements: IReadOnlyList_1<Expression>, tree: Expression): Expression;
    Replace(original: Expression, replacement: Expression, tree: Expression): Expression;
};


export type ReplacingExpressionVisitor = ReplacingExpressionVisitor$instance;

export interface ShapedQueryCompilingExpressionVisitor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ShapedQueryCompilingExpressionVisitor: never;

    readonly Dependencies: ShapedQueryCompilingExpressionVisitorDependencies;
    readonly QueryCompilationContext: QueryCompilationContext;
    AddStructuralTypeInitialization(shaper: StructuralTypeShaperExpression, instanceVariable: ParameterExpression, variables: List_1<ParameterExpression>, expressions: List_1<Expression>): void;
    InjectEntityMaterializers(expression: Expression): Expression;
    InjectStructuralTypeMaterializers(expression: Expression): Expression;
    VerifyNoClientConstant(expression: Expression): void;
    VisitExtension(extensionExpression: Expression): Expression;
    VisitShapedQuery(shapedQueryExpression: ShapedQueryExpression): Expression;
}


export const ShapedQueryCompilingExpressionVisitor: (abstract new(dependencies: ShapedQueryCompilingExpressionVisitorDependencies, queryCompilationContext: QueryCompilationContext) => ShapedQueryCompilingExpressionVisitor) & {
    CreateNullKeyValueInNoTrackingQuery(entityType: IEntityType, properties: IReadOnlyList_1<IProperty>, keyValues: (unknown | null)[]): Exception;
    SingleAsync<TSource extends unknown>(asyncEnumerable: IAsyncEnumerable_1<TSource>, cancellationToken?: CancellationToken): Task_1<TSource>;
    SingleOrDefaultAsync<TSource extends unknown>(asyncEnumerable: IAsyncEnumerable_1<TSource>, cancellationToken?: CancellationToken): Task_1<TSource | null>;
};


export type ShapedQueryCompilingExpressionVisitor = ShapedQueryCompilingExpressionVisitor$instance;

export interface ShapedQueryCompilingExpressionVisitorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ShapedQueryCompilingExpressionVisitorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    ContextServices: IDbContextServices;
    CoreSingletonOptions: ICoreSingletonOptions;
    EntityMaterializerSource: IStructuralTypeMaterializerSource;
    LiftableConstantFactory: ILiftableConstantFactory;
    MemoryCache: IMemoryCache;
    Model: IModel;
    QueryLogger: IDiagnosticsLogger_1<DbLoggerCategory_Query>;
    SingletonInterceptors: IEnumerable_1<ISingletonInterceptor>;
    TypeMappingSource: ITypeMappingSource;
    _Clone_$(): ShapedQueryCompilingExpressionVisitorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: ShapedQueryCompilingExpressionVisitorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const ShapedQueryCompilingExpressionVisitorDependencies: {
    new(entityMaterializerSource: IStructuralTypeMaterializerSource, typeMappingSource: ITypeMappingSource, memoryCache: IMemoryCache, coreSingletonOptions: ICoreSingletonOptions, model: IModel, liftableConstantFactory: ILiftableConstantFactory, queryLogger: IDiagnosticsLogger_1<DbLoggerCategory_Query>, singletonInterceptors: IEnumerable_1<ISingletonInterceptor>, contextServices: IDbContextServices): ShapedQueryCompilingExpressionVisitorDependencies;
};


export type ShapedQueryCompilingExpressionVisitorDependencies = ShapedQueryCompilingExpressionVisitorDependencies$instance;

export interface ShapedQueryExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_ShapedQueryExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly NodeType: ExpressionType;
    readonly QueryExpression: Expression;
    readonly ResultCardinality: ResultCardinality;
    readonly ShaperExpression: Expression;
    readonly Type: Type;
    Update(queryExpression: Expression, shaperExpression: Expression): ShapedQueryExpression;
    UpdateQueryExpression(queryExpression: Expression): ShapedQueryExpression;
    UpdateResultCardinality(resultCardinality: ResultCardinality): ShapedQueryExpression;
    UpdateShaperExpression(shaperExpression: Expression): ShapedQueryExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const ShapedQueryExpression: {
    new(queryExpression: Expression, shaperExpression: Expression): ShapedQueryExpression;
};


export interface __ShapedQueryExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type ShapedQueryExpression = ShapedQueryExpression$instance & __ShapedQueryExpression$views;


export interface SqlAliasManager$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_SqlAliasManager: never;

    GenerateTableAlias(name: string): string;
    GenerateTableAlias(modelTable: ITableBase): string;
    PostprocessAliases(expression: Expression): Expression;
    RemapTableAliases(usedAliases: IReadOnlySet_1<System_Internal.String>): Dictionary_2<System_Internal.String, System_Internal.String> | null;
}


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


export type SqlAliasManager = SqlAliasManager$instance;

export interface SqlAliasManagerFactory$instance extends ISqlAliasManagerFactory$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_SqlAliasManagerFactory: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ISqlAliasManagerFactory: never;

    Create(): SqlAliasManager;
}


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


export interface __SqlAliasManagerFactory$views {
    As_ISqlAliasManagerFactory(): ISqlAliasManagerFactory$instance;
}

export type SqlAliasManagerFactory = SqlAliasManagerFactory$instance & __SqlAliasManagerFactory$views;


export interface SqlExpressionFactory$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_SqlExpressionFactory: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_ISqlExpressionFactory: never;

    readonly Dependencies: SqlExpressionFactoryDependencies;
    Add(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    And(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    AndAlso(left: SqlExpression, right: SqlExpression): SqlExpression;
    ApplyDefaultTypeMapping(sqlExpression: SqlExpression | null): SqlExpression | null;
    ApplyTypeMapping(sqlExpression: SqlExpression | null, typeMapping: RelationalTypeMapping | null): SqlExpression | null;
    Case(operand: SqlExpression | null, whenClauses: IReadOnlyList_1<CaseWhenClause>, elseResult: SqlExpression | null, existingExpression?: SqlExpression | null): SqlExpression;
    Case(whenClauses: IReadOnlyList_1<CaseWhenClause>, elseResult: SqlExpression | null): SqlExpression;
    Coalesce(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Constant(value: unknown, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Constant(value: unknown | null, type: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Constant(value: unknown, sensitive: boolean, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Constant(value: unknown | null, type: Type, sensitive: boolean, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Convert(operand: SqlExpression, type: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Divide(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Equal(left: SqlExpression, right: SqlExpression): SqlExpression;
    Exists(subquery: SelectExpression): SqlExpression;
    Fragment(sql: string, type?: Type | null, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Function(name: string, arguments: IEnumerable_1<SqlExpression>, nullable: boolean, argumentsPropagateNullability: IEnumerable_1<System_Internal.Boolean>, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Function(schema: string | null, name: string, arguments: IEnumerable_1<SqlExpression>, nullable: boolean, argumentsPropagateNullability: IEnumerable_1<System_Internal.Boolean>, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Function(instance: SqlExpression, name: string, arguments: IEnumerable_1<SqlExpression>, nullable: boolean, instancePropagatesNullability: boolean, argumentsPropagateNullability: IEnumerable_1<System_Internal.Boolean>, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    GreaterThan(left: SqlExpression, right: SqlExpression): SqlExpression;
    GreaterThanOrEqual(left: SqlExpression, right: SqlExpression): SqlExpression;
    In(item: SqlExpression, subquery: SelectExpression): SqlExpression;
    In(item: SqlExpression, values: IReadOnlyList_1<SqlExpression>): SqlExpression;
    In(item: SqlExpression, valuesParameter: SqlParameterExpression): SqlExpression;
    IsNotNull(operand: SqlExpression): SqlExpression;
    IsNull(operand: SqlExpression): SqlExpression;
    LessThan(left: SqlExpression, right: SqlExpression): SqlExpression;
    LessThanOrEqual(left: SqlExpression, right: SqlExpression): SqlExpression;
    Like(match: SqlExpression, pattern: SqlExpression, escapeChar?: SqlExpression | null): SqlExpression;
    MakeBinary(operatorType: ExpressionType, left: SqlExpression, right: SqlExpression, typeMapping: RelationalTypeMapping | null, existingExpression?: SqlExpression | null): SqlExpression | null;
    MakeUnary(operatorType: ExpressionType, operand: SqlExpression, type: Type, typeMapping?: RelationalTypeMapping | null, existingExpression?: SqlExpression | null): SqlExpression | null;
    Modulo(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Multiply(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Negate(operand: SqlExpression): SqlExpression;
    NiladicFunction(name: string, nullable: boolean, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    NiladicFunction(schema: string, name: string, nullable: boolean, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    NiladicFunction(instance: SqlExpression, name: string, nullable: boolean, instancePropagatesNullability: boolean, returnType: Type, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    Not(operand: SqlExpression): SqlExpression;
    NotEqual(left: SqlExpression, right: SqlExpression): SqlExpression;
    Or(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
    OrElse(left: SqlExpression, right: SqlExpression): SqlExpression;
    Subtract(left: SqlExpression, right: SqlExpression, typeMapping?: RelationalTypeMapping | null): SqlExpression;
}


export const SqlExpressionFactory: {
    new(dependencies: SqlExpressionFactoryDependencies): SqlExpressionFactory;
};


export interface __SqlExpressionFactory$views {
    As_ISqlExpressionFactory(): ISqlExpressionFactory$instance;
}

export type SqlExpressionFactory = SqlExpressionFactory$instance & __SqlExpressionFactory$views;


export interface SqlExpressionFactoryDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_SqlExpressionFactoryDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    Model: IModel;
    TypeMappingSource: IRelationalTypeMappingSource;
    _Clone_$(): SqlExpressionFactoryDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: SqlExpressionFactoryDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const SqlExpressionFactoryDependencies: {
    new(model: IModel, typeMappingSource: IRelationalTypeMappingSource): SqlExpressionFactoryDependencies;
};


export type SqlExpressionFactoryDependencies = SqlExpressionFactoryDependencies$instance;

export interface SqlExpressionVisitor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_SqlExpressionVisitor: never;

    VisitAtTimeZone(atTimeZoneExpression: AtTimeZoneExpression): Expression;
    VisitCase(caseExpression: CaseExpression): Expression;
    VisitCollate(collateExpression: CollateExpression): Expression;
    VisitColumn(columnExpression: ColumnExpression): Expression;
    VisitCrossApply(crossApplyExpression: CrossApplyExpression): Expression;
    VisitCrossJoin(crossJoinExpression: CrossJoinExpression): Expression;
    VisitDelete(deleteExpression: DeleteExpression): Expression;
    VisitDistinct(distinctExpression: DistinctExpression): Expression;
    VisitExcept(exceptExpression: ExceptExpression): Expression;
    VisitExists(existsExpression: ExistsExpression): Expression;
    VisitExtension(extensionExpression: Expression): Expression;
    VisitFromSql(fromSqlExpression: FromSqlExpression): Expression;
    VisitIn(inExpression: InExpression): Expression;
    VisitInnerJoin(innerJoinExpression: InnerJoinExpression): Expression;
    VisitIntersect(intersectExpression: IntersectExpression): Expression;
    VisitJsonScalar(jsonScalarExpression: JsonScalarExpression): Expression;
    VisitLeftJoin(leftJoinExpression: LeftJoinExpression): Expression;
    VisitLike(likeExpression: LikeExpression): Expression;
    VisitOrdering(orderingExpression: OrderingExpression): Expression;
    VisitOuterApply(outerApplyExpression: OuterApplyExpression): Expression;
    VisitProjection(projectionExpression: ProjectionExpression): Expression;
    VisitRightJoin(rightJoinExpression: RightJoinExpression): Expression;
    VisitRowNumber(rowNumberExpression: RowNumberExpression): Expression;
    VisitRowValue(rowValueExpression: RowValueExpression): Expression;
    VisitScalarSubquery(scalarSubqueryExpression: ScalarSubqueryExpression): Expression;
    VisitSelect(selectExpression: SelectExpression): Expression;
    VisitSqlBinary(sqlBinaryExpression: SqlBinaryExpression): Expression;
    VisitSqlConstant(sqlConstantExpression: SqlConstantExpression): Expression;
    VisitSqlFragment(sqlFragmentExpression: SqlFragmentExpression): Expression;
    VisitSqlFunction(sqlFunctionExpression: SqlFunctionExpression): Expression;
    VisitSqlParameter(sqlParameterExpression: SqlParameterExpression): Expression;
    VisitSqlUnary(sqlUnaryExpression: SqlUnaryExpression): Expression;
    VisitTable(tableExpression: TableExpression): Expression;
    VisitTableValuedFunction(tableValuedFunctionExpression: TableValuedFunctionExpression): Expression;
    VisitUnion(unionExpression: UnionExpression): Expression;
    VisitUpdate(updateExpression: UpdateExpression): Expression;
    VisitValues(valuesExpression: ValuesExpression): Expression;
}


export const SqlExpressionVisitor: (abstract new() => SqlExpressionVisitor) & {
};


export type SqlExpressionVisitor = SqlExpressionVisitor$instance;

export interface SqlNullabilityProcessor$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_SqlNullabilityProcessor: never;

    readonly CollectionParameterTranslationMode: ParameterTranslationMode;
    readonly Dependencies: RelationalParameterBasedSqlProcessorDependencies;
    ParametersDecorator: ParametersCacheDecorator;
    readonly PreferExistsToInWithCoalesce: boolean;
    readonly UseRelationalNulls: boolean;
    AddNonNullableColumn(columnExpression: ColumnExpression): void;
    CalculateParameterBucketSize(count: int, elementTypeMapping: RelationalTypeMapping): int;
    IsCollectionTable(table: TableExpressionBase, collection: Expression | null): boolean;
    OptimizeNotExpression(expression: SqlExpression): SqlExpression;
    Process(queryExpression: Expression, parametersDecorator: ParametersCacheDecorator): Expression;
    ProcessValuesOrderingColumn(valuesExpression: ValuesExpression, expressions: IReadOnlyList_1<SqlExpression>, intTypeMapping: IntTypeMapping, counter: int): IReadOnlyList_1<SqlExpression>;
    TryMakeNonNullable(selectExpression: SelectExpression, rewrittenSelectExpression: SelectExpression | null, foundNull: Nullable_1<System_Internal.Boolean>): boolean;
    UpdateParameterCollection(table: TableExpressionBase, newCollectionParameter: SqlParameterExpression): TableExpressionBase;
    Visit(selectExpression: SelectExpression, visitProjection?: boolean): SelectExpression;
    Visit(sqlExpression: SqlExpression | null, nullable: boolean): SqlExpression | null;
    Visit(sqlExpression: SqlExpression | null, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression | null;
    VisitAtTimeZone(atTimeZoneExpression: AtTimeZoneExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitCase(caseExpression: CaseExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitCollate(collateExpression: CollateExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitColumn(columnExpression: ColumnExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitCustomSqlExpression(sqlExpression: SqlExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitDistinct(distinctExpression: DistinctExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitExists(existsExpression: ExistsExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitExtension(node: Expression): Expression;
    VisitIn(inExpression: InExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitJsonScalar(jsonScalarExpression: JsonScalarExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitLike(likeExpression: LikeExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitRowNumber(rowNumberExpression: RowNumberExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitRowValue(rowValueExpression: RowValueExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitScalarSubquery(scalarSubqueryExpression: ScalarSubqueryExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitSqlBinary(sqlBinaryExpression: SqlBinaryExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitSqlConstant(sqlConstantExpression: SqlConstantExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitSqlFragment(sqlFragmentExpression: SqlFragmentExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitSqlFunction(sqlFunctionExpression: SqlFunctionExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitSqlParameter(sqlParameterExpression: SqlParameterExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
    VisitSqlUnary(sqlUnaryExpression: SqlUnaryExpression, allowOptimizedExpansion: boolean, nullable: boolean): SqlExpression;
}


export const SqlNullabilityProcessor: {
    new(dependencies: RelationalParameterBasedSqlProcessorDependencies, parameters: RelationalParameterBasedSqlProcessorParameters): SqlNullabilityProcessor;
};


export type SqlNullabilityProcessor = SqlNullabilityProcessor$instance;

export interface SqlTreePruner$instance extends ExpressionVisitor {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_SqlTreePruner: never;

    get CurrentTableAlias(): string | null;
    set CurrentTableAlias(value: string | null);
    readonly ReferencedColumnMap: IReadOnlyDictionary_2<System_Internal.String, HashSet_1<System_Internal.String>>;
    Prune(expression: Expression): Expression;
    PruneSelect(select: SelectExpression, preserveProjection: boolean): SelectExpression;
    PruneTopLevelSelect(select: SelectExpression): SelectExpression;
    PruneValues(values: ValuesExpression): ValuesExpression;
    VisitExtension(node: Expression): Expression;
}


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


export type SqlTreePruner = SqlTreePruner$instance;

export interface StructuralTypeProjectionExpression$instance extends Expression {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_StructuralTypeProjectionExpression: never;

    readonly DiscriminatorExpression: SqlExpression | null;
    readonly IsNullable: boolean;
    readonly NodeType: ExpressionType;
    readonly StructuralType: ITypeBase;
    readonly TableMap: IReadOnlyDictionary_2<ITableBase, System_Internal.String>;
    readonly Type: Type;
    AddNavigationBinding(navigation: INavigation, shaper: StructuralTypeShaperExpression): void;
    BindComplexProperty(complexProperty: IComplexProperty): Expression;
    BindNavigation(navigation: INavigation): StructuralTypeShaperExpression | null;
    BindProperty(property: IProperty): ColumnExpression;
    MakeNullable(): StructuralTypeProjectionExpression;
    ToString(): string;
    UpdateEntityType(derivedType: IEntityType): StructuralTypeProjectionExpression;
    UpdateTableMap(newTableMap: IReadOnlyDictionary_2<ITableBase, System_Internal.String>): StructuralTypeProjectionExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
}


export const StructuralTypeProjectionExpression: {
    new(type: ITypeBase, propertyExpressionMap: IReadOnlyDictionary_2<IProperty, ColumnExpression>, tableMap: IReadOnlyDictionary_2<ITableBase, System_Internal.String>, nullable: boolean, discriminatorExpression: SqlExpression | null): StructuralTypeProjectionExpression;
    new(type: ITypeBase, propertyExpressionMap: IReadOnlyDictionary_2<IProperty, ColumnExpression>, complexPropertyCache: Dictionary_2<IComplexProperty, Expression>, tableMap: IReadOnlyDictionary_2<ITableBase, System_Internal.String>, nullable: boolean, discriminatorExpression: SqlExpression | null): StructuralTypeProjectionExpression;
};


export type StructuralTypeProjectionExpression = StructuralTypeProjectionExpression$instance;

export interface StructuralTypeShaperExpression$instance extends Expression, IPrintableExpression$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_StructuralTypeShaperExpression: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Query_IPrintableExpression: never;

    readonly IsNullable: boolean;
    readonly MaterializationCondition: LambdaExpression;
    readonly NodeType: ExpressionType;
    readonly StructuralType: ITypeBase;
    readonly Type: Type;
    readonly ValueBufferExpression: Expression;
    DebuggerDisplay(): string;
    GenerateMaterializationCondition(type: ITypeBase, nullable: boolean): LambdaExpression;
    MakeClrTypeNonNullable(): StructuralTypeShaperExpression;
    MakeClrTypeNullable(): StructuralTypeShaperExpression;
    MakeNullable(nullable?: boolean): StructuralTypeShaperExpression;
    Update(valueBufferExpression: Expression): StructuralTypeShaperExpression;
    VisitChildren(visitor: ExpressionVisitor): Expression;
    WithType(type: ITypeBase): StructuralTypeShaperExpression;
}


export const StructuralTypeShaperExpression: {
    new(type: ITypeBase, valueBufferExpression: Expression, nullable: boolean): StructuralTypeShaperExpression;
    CreateUnableToDiscriminateException(type: ITypeBase, discriminator: unknown | null): Exception;
    CreateUnableToDiscriminateExceptionExpression(type: ITypeBase, discriminatorValue: Expression): Expression;
};


export interface __StructuralTypeShaperExpression$views {
    As_IPrintableExpression(): IPrintableExpression$instance;
}

export type StructuralTypeShaperExpression = StructuralTypeShaperExpression$instance & __StructuralTypeShaperExpression$views;


export interface UpdateSettersBuilder$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_UpdateSettersBuilder: never;

    BuildSettersExpression(): NewArrayExpression;
    SetProperty(propertyExpression: LambdaExpression, valueExpression: LambdaExpression): UpdateSettersBuilder;
    SetProperty(propertyExpression: LambdaExpression, valueExpression: Expression): UpdateSettersBuilder;
}


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


export type UpdateSettersBuilder = UpdateSettersBuilder$instance;

export interface UpdateSettersBuilder_1$instance<TSource extends unknown> extends UpdateSettersBuilder {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Query_UpdateSettersBuilder_1: never;

    SetProperty<TProperty extends unknown>(propertyExpression: Expression_1<Func_2<TSource, TProperty>>, valueExpression: Expression_1<Func_2<TSource, TProperty>>): UpdateSettersBuilder_1<TSource>;
    SetProperty<TProperty extends unknown>(propertyExpression: Expression_1<Func_2<TSource, TProperty>>, valueExpression: TProperty): UpdateSettersBuilder_1<TSource>;
    SetProperty(propertyExpression: LambdaExpression, valueExpression: LambdaExpression): UpdateSettersBuilder;
    SetProperty(propertyExpression: LambdaExpression, valueExpression: Expression): UpdateSettersBuilder;
}


export const UpdateSettersBuilder_1: {
    new<TSource extends unknown>(): UpdateSettersBuilder_1<TSource>;
};


export type UpdateSettersBuilder_1<TSource extends unknown> = UpdateSettersBuilder_1$instance<TSource>;

export abstract class ExpressionExtensions$instance {
    static InferTypeMapping(...expressions: SqlExpression[]): RelationalTypeMapping | null;
    static InferTypeMapping(expressions: IReadOnlyList_1<SqlExpression>): RelationalTypeMapping | null;
}


export type ExpressionExtensions = ExpressionExtensions$instance;

export abstract class LiftableConstantExpressionHelpers$instance {
    static BuildClrCollectionAccessor(structuralProperty: IPropertyBase | null, liftableConstantContextParameter: ParameterExpression): Expression;
    static BuildClrCollectionAccessorLambda(structuralProperty: IPropertyBase | null): Expression_1<Func_2<MaterializerLiftableConstantContext, unknown>>;
    static BuildMemberAccessForEntityOrComplexType(targetType: ITypeBase, liftableConstantContextParameter: ParameterExpression): Expression;
    static BuildMemberAccessForProperty(property: IPropertyBase | null, liftableConstantContextParameter: ParameterExpression): Expression;
    static BuildMemberAccessLambdaForProperty(property: IPropertyBase | null): Expression_1<Func_2<MaterializerLiftableConstantContext, unknown>>;
    static BuildMemberAccessLambdaForStructuralType(type: ITypeBase): Expression_1<Func_2<MaterializerLiftableConstantContext, unknown>>;
    static BuildStructuralPropertyAccess(structuralProperty: IPropertyBase | null, liftableConstantContextParameter: ParameterExpression): Expression;
    static BuildStructuralPropertyAccessLambda(structuralProperty: IPropertyBase | null): Expression_1<Func_2<MaterializerLiftableConstantContext, unknown>>;
    static IsLiteral(value: unknown | null): boolean;
}


export type LiftableConstantExpressionHelpers = LiftableConstantExpressionHelpers$instance;

export abstract class QueryableMethods$instance {
    static readonly All: MethodInfo;
    static readonly AnyWithoutPredicate: MethodInfo;
    static readonly AnyWithPredicate: MethodInfo;
    static readonly AsQueryable: MethodInfo;
    static readonly Cast: MethodInfo;
    static readonly Concat: MethodInfo;
    static readonly Contains: MethodInfo;
    static readonly CountWithoutPredicate: MethodInfo;
    static readonly CountWithPredicate: MethodInfo;
    static readonly DefaultIfEmptyWithoutArgument: MethodInfo;
    static readonly DefaultIfEmptyWithArgument: MethodInfo;
    static readonly Distinct: MethodInfo;
    static readonly ElementAt: MethodInfo;
    static readonly ElementAtOrDefault: MethodInfo;
    static readonly Except: MethodInfo;
    static readonly FirstWithoutPredicate: MethodInfo;
    static readonly FirstWithPredicate: MethodInfo;
    static readonly FirstOrDefaultWithoutPredicate: MethodInfo;
    static readonly FirstOrDefaultWithPredicate: MethodInfo;
    static readonly GroupByWithKeySelector: MethodInfo;
    static readonly GroupByWithKeyElementSelector: MethodInfo;
    static readonly GroupByWithKeyElementResultSelector: MethodInfo;
    static readonly GroupByWithKeyResultSelector: MethodInfo;
    static readonly GroupJoin: MethodInfo;
    static readonly Intersect: MethodInfo;
    static readonly Join: MethodInfo;
    static readonly LastWithoutPredicate: MethodInfo;
    static readonly LastWithPredicate: MethodInfo;
    static readonly LastOrDefaultWithoutPredicate: MethodInfo;
    static readonly LastOrDefaultWithPredicate: MethodInfo;
    static readonly LeftJoin: MethodInfo;
    static readonly LongCountWithoutPredicate: MethodInfo;
    static readonly LongCountWithPredicate: MethodInfo;
    static readonly MaxWithoutSelector: MethodInfo;
    static readonly MaxWithSelector: MethodInfo;
    static readonly MinWithoutSelector: MethodInfo;
    static readonly MinWithSelector: MethodInfo;
    static readonly OfType: MethodInfo;
    static readonly Order: MethodInfo;
    static readonly OrderBy: MethodInfo;
    static readonly OrderByDescending: MethodInfo;
    static readonly OrderDescending: MethodInfo;
    static readonly Reverse: MethodInfo;
    static readonly RightJoin: MethodInfo;
    static readonly Select: MethodInfo;
    static readonly SelectManyWithoutCollectionSelector: MethodInfo;
    static readonly SelectManyWithCollectionSelector: MethodInfo;
    static readonly SingleWithoutPredicate: MethodInfo;
    static readonly SingleWithPredicate: MethodInfo;
    static readonly SingleOrDefaultWithoutPredicate: MethodInfo;
    static readonly SingleOrDefaultWithPredicate: MethodInfo;
    static readonly Skip: MethodInfo;
    static readonly SkipWhile: MethodInfo;
    static readonly Take: MethodInfo;
    static readonly TakeWhile: MethodInfo;
    static readonly ThenBy: MethodInfo;
    static readonly ThenByDescending: MethodInfo;
    static readonly Union: MethodInfo;
    static readonly Where: MethodInfo;
    static GetAverageWithoutSelector(type: Type): MethodInfo;
    static GetAverageWithSelector(type: Type): MethodInfo;
    static GetSumWithoutSelector(type: Type): MethodInfo;
    static GetSumWithSelector(type: Type): MethodInfo;
    static IsAverageWithoutSelector(methodInfo: MethodInfo): boolean;
    static IsAverageWithSelector(methodInfo: MethodInfo): boolean;
    static IsSumWithoutSelector(methodInfo: MethodInfo): boolean;
    static IsSumWithSelector(methodInfo: MethodInfo): boolean;
}


export type QueryableMethods = QueryableMethods$instance;

export abstract class RelationalExpressionQuotingUtilities$instance {
    static QuoteAnnotations(annotations: IReadOnlyDictionary_2<System_Internal.String, IAnnotation> | null): Expression;
    static QuoteOrNull<T extends unknown & IRelationalQuotableExpression>(expression: T | null): Expression;
    static QuoteTableBase(tableBase: ITableBase): Expression;
    static QuoteTags(tags: ISet_1<System_Internal.String>): Expression;
    static QuoteTypeMapping(typeMapping: RelationalTypeMapping | null): Expression;
}


export type RelationalExpressionQuotingUtilities = RelationalExpressionQuotingUtilities$instance;

export abstract class TransparentIdentifierFactory$instance {
    static Create(outerType: Type, innerType: Type): Type;
}


export type TransparentIdentifierFactory = TransparentIdentifierFactory$instance;