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

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


// Import types from other namespaces
import type { CascadeTiming, ChangeTrackerDebugStringOptions, EntityEntry } from "../../Microsoft.EntityFrameworkCore.ChangeTracking/internal/index.js";
import type { IDiagnosticsLogger_1, IRelationalCommandDiagnosticsLogger } from "../../Microsoft.EntityFrameworkCore.Diagnostics/internal/index.js";
import * as Microsoft_EntityFrameworkCore_Infrastructure_Internal from "../../Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
import type { IAnnotatable, ICurrentDbContext, IResettableService } from "../../Microsoft.EntityFrameworkCore.Infrastructure/internal/index.js";
import type { IColumn, IColumnBase, IComplexProperty, IEntityType, IForeignKey, IKey, IModel, IProperty, IPropertyBase, IStoreStoredProcedure, ITable } from "../../Microsoft.EntityFrameworkCore.Metadata/internal/index.js";
import type { IRelationalCommandBuilder, IRelationalCommandBuilderFactory, IRelationalConnection, IRelationalTypeMappingSource, ISqlGenerationHelper, RawSqlCommand, RelationalDataReader, RelationalTypeMapping } from "../../Microsoft.EntityFrameworkCore.Storage/internal/index.js";
import type { DbContext, DbLoggerCategory_Update, EntityState } from "../../Microsoft.EntityFrameworkCore/internal/index.js";
import type { Dictionary_2, IComparer_1, IDictionary_2, IEnumerable_1, IEqualityComparer_1, IList_1, IReadOnlyList_1 } from "@tsonic/dotnet/System.Collections.Generic/internal/index.js";
import type { DbParameterCollection } from "@tsonic/dotnet/System.Data.Common/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 { Boolean as ClrBoolean, Enum, Func_1, IComparable, IConvertible, IEquatable_1, IFormattable, Int32, ISpanFormattable, Nullable_1, Object as ClrObject, String as ClrString, ValueType, Void } from "@tsonic/dotnet/System/internal/index.js";

export enum ResultSetMapping {
    NoResults = 0,
    HasResultRow = 1,
    NotLastInResultSet = 3,
    LastInResultSet = 5,
    ResultSetWithRowsAffectedOnly = 9,
    IsPositionalResultMappingEnabled = 17,
    HasOutputParameters = 32
}


export interface IBatchExecutor$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IBatchExecutor: never;

    Execute(commandBatches: IEnumerable_1<ModificationCommandBatch>, connection: IRelationalConnection): int;
    ExecuteAsync(commandBatches: IEnumerable_1<ModificationCommandBatch>, connection: IRelationalConnection, cancellationToken?: CancellationToken): Task_1<System_Internal.Int32>;
}


export type IBatchExecutor = IBatchExecutor$instance;

export interface IColumnModification$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IColumnModification: never;

    readonly Entry: IUpdateEntry | null;
    readonly Property: IProperty | null;
    readonly Column: IColumnBase | null;
    readonly TypeMapping: RelationalTypeMapping | null;
    readonly IsNullable: Nullable_1<System_Internal.Boolean>;
    IsRead: boolean;
    IsWrite: boolean;
    IsCondition: boolean;
    IsKey: boolean;
    readonly UseOriginalValueParameter: boolean;
    readonly UseCurrentValueParameter: boolean;
    readonly UseOriginalValue: boolean;
    readonly UseCurrentValue: boolean;
    readonly UseParameter: boolean;
    readonly ParameterName: string | null;
    readonly OriginalParameterName: string | null;
    readonly ColumnName: string;
    readonly ColumnType: string | null;
    get OriginalValue(): unknown | null;
    set OriginalValue(value: unknown | null);
    get Value(): unknown | null;
    set Value(value: unknown | null);
    readonly JsonPath: string | null;
    AddSharedColumnModification(modification: IColumnModification): void;
    ResetParameterNames(): void;
}


export type IColumnModification = IColumnModification$instance;

export interface ICommandBatchPreparer$instance extends IResettableService {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_ICommandBatchPreparer: never;

    BatchCommands(entries: IList_1<IUpdateEntry>, updateAdapter: IUpdateAdapter): IEnumerable_1<ModificationCommandBatch>;
    CreateCommandBatches(commandSet: IEnumerable_1<IReadOnlyModificationCommand>, moreCommandSets: boolean): IEnumerable_1<ModificationCommandBatch>;
    ResetState(): void;
    ResetStateAsync(cancellationToken?: CancellationToken): Task;
}


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

export type ICommandBatchPreparer = ICommandBatchPreparer$instance;

export interface IModificationCommand$instance extends IReadOnlyModificationCommand {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IModificationCommand: never;

    readonly Table: ITable | null;
    readonly StoreStoredProcedure: IStoreStoredProcedure | null;
    readonly TableName: string;
    readonly Schema: string | null;
    readonly ColumnModifications: IReadOnlyList_1<IColumnModification>;
    readonly Entries: IReadOnlyList_1<IUpdateEntry>;
    readonly EntityState: EntityState;
    readonly RowsAffectedColumn: IColumnBase | null;
    AddEntry(entry: IUpdateEntry, mainEntry: boolean): void;
    PropagateOutputParameters(parameterCollection: DbParameterCollection, baseParameterIndex: int): void;
    PropagateResults(relationalReader: RelationalDataReader): void;
}


export interface IModificationCommand$instance extends IReadOnlyModificationCommand$instance {}

export type IModificationCommand = IModificationCommand$instance;

export interface IModificationCommandBatchFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IModificationCommandBatchFactory: never;

    Create(): ModificationCommandBatch;
}


export type IModificationCommandBatchFactory = IModificationCommandBatchFactory$instance;

export interface IModificationCommandFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IModificationCommandFactory: never;

    CreateModificationCommand(modificationCommandParameters: ModificationCommandParameters): IModificationCommand;
    CreateNonTrackedModificationCommand(modificationCommandParameters: NonTrackedModificationCommandParameters): INonTrackedModificationCommand;
}


export type IModificationCommandFactory = IModificationCommandFactory$instance;

export interface INonTrackedModificationCommand$instance extends IReadOnlyModificationCommand {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_INonTrackedModificationCommand: never;

    EntityState: EntityState;
    readonly Table: ITable | null;
    readonly StoreStoredProcedure: IStoreStoredProcedure | null;
    readonly TableName: string;
    readonly Schema: string | null;
    readonly ColumnModifications: IReadOnlyList_1<IColumnModification>;
    readonly Entries: IReadOnlyList_1<IUpdateEntry>;
    readonly RowsAffectedColumn: IColumnBase | null;
    AddColumnModification(columnModificationParameters: ColumnModificationParameters): IColumnModification;
    PropagateOutputParameters(parameterCollection: DbParameterCollection, baseParameterIndex: int): void;
    PropagateResults(relationalReader: RelationalDataReader): void;
}


export type INonTrackedModificationCommand = INonTrackedModificationCommand$instance;

export interface IReadOnlyModificationCommand$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IReadOnlyModificationCommand: never;

    readonly Table: ITable | null;
    readonly StoreStoredProcedure: IStoreStoredProcedure | null;
    readonly TableName: string;
    readonly Schema: string | null;
    readonly ColumnModifications: IReadOnlyList_1<IColumnModification>;
    readonly Entries: IReadOnlyList_1<IUpdateEntry>;
    readonly EntityState: EntityState;
    readonly RowsAffectedColumn: IColumnBase | null;
    PropagateOutputParameters(parameterCollection: DbParameterCollection, baseParameterIndex: int): void;
    PropagateResults(relationalReader: RelationalDataReader): void;
}


export type IReadOnlyModificationCommand = IReadOnlyModificationCommand$instance;

export interface IUpdateAdapter$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IUpdateAdapter: never;

    DeleteOrphansTiming: CascadeTiming;
    CascadeDeleteTiming: CascadeTiming;
    readonly Entries: IEnumerable_1<IUpdateEntry>;
    readonly Model: IModel;
    CascadeDelete(entry: IUpdateEntry, foreignKeys?: IEnumerable_1<IForeignKey> | null): void;
    CreateEntry(values: IDictionary_2<System_Internal.String, unknown | null>, entityType: IEntityType): IUpdateEntry;
    DetectChanges(): void;
    FindPrincipal(dependentEntry: IUpdateEntry, foreignKey: IForeignKey): IUpdateEntry | null;
    GetDependents(principalEntry: IUpdateEntry, foreignKey: IForeignKey): IEnumerable_1<IUpdateEntry>;
    GetEntriesToSave(): IList_1<IUpdateEntry>;
    TryGetEntry(key: IKey, keyValues: (unknown | null)[]): IUpdateEntry | null;
}


export type IUpdateAdapter = IUpdateAdapter$instance;

export interface IUpdateAdapterFactory$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IUpdateAdapterFactory: never;

    Create(): IUpdateAdapter;
    CreateStandalone(model?: IModel | null): IUpdateAdapter;
}


export type IUpdateAdapterFactory = IUpdateAdapterFactory$instance;

export interface IUpdateEntry$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IUpdateEntry: never;

    readonly Context: DbContext;
    readonly EntityType: IEntityType;
    EntityState: EntityState;
    readonly SharedIdentityEntry: IUpdateEntry | null;
    CanHaveOriginalValue(propertyBase: IPropertyBase): boolean;
    GetCurrentValue(propertyBase: IPropertyBase): unknown | null;
    GetCurrentValue<TProperty extends unknown>(propertyBase: IPropertyBase): TProperty;
    GetOriginalValue<TProperty extends unknown>(property: IProperty): TProperty;
    IsModified(property: IComplexProperty): boolean;
    IsModified(property: IProperty): boolean;
    SetOriginalValue(property: IProperty, value: unknown | null): void;
    SetPropertyModified(property: IProperty): void;
    SetStoreGeneratedValue(property: IProperty, value: unknown | null, setModified?: boolean): void;
    ToEntityEntry(): EntityEntry;
}


export type IUpdateEntry = IUpdateEntry$instance;

export interface IUpdateSqlGenerator$instance {
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IUpdateSqlGenerator: never;

    AppendBatchHeader(commandStringBuilder: StringBuilder): void;
    AppendDeleteOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendDeleteOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int): ResultSetMapping;
    AppendNextSequenceValueOperation(commandStringBuilder: StringBuilder, name: string, schema: string | null): void;
    GenerateNextSequenceValueOperation(name: string, schema: string | null): string;
}


export type IUpdateSqlGenerator = IUpdateSqlGenerator$instance;

export interface ColumnModificationParameters$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_ColumnModificationParameters: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    get Column(): IColumnBase | null;
    set Column(value: IColumnBase | null);
    ColumnName: string;
    get ColumnType(): string | null;
    set ColumnType(value: string | null);
    get Entry(): IUpdateEntry | null;
    set Entry(value: IUpdateEntry | null);
    get GenerateParameterName(): Func_1<System_Internal.String> | null;
    set GenerateParameterName(value: Func_1<System_Internal.String> | null);
    IsCondition: boolean;
    IsKey: boolean;
    get IsNullable(): Nullable_1<System_Internal.Boolean>;
    set IsNullable(value: Nullable_1<System_Internal.Boolean> | boolean);
    IsRead: boolean;
    IsWrite: boolean;
    get JsonPath(): string | null;
    set JsonPath(value: string | null);
    get OriginalValue(): unknown | null;
    set OriginalValue(value: unknown | null);
    get Property(): IProperty | null;
    set Property(value: IProperty | null);
    SensitiveLoggingEnabled: boolean;
    get TypeMapping(): RelationalTypeMapping | null;
    set TypeMapping(value: RelationalTypeMapping | null);
    get Value(): unknown | null;
    set Value(value: unknown | null);
    Equals(obj: unknown): boolean;
    Equals(other: ColumnModificationParameters): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const ColumnModificationParameters: {
    new(columnName: string, originalValue: unknown | null, value: unknown | null, property: IProperty | null, columnType: string | null, typeMapping: RelationalTypeMapping | null, read: boolean, write: boolean, key: boolean, condition: boolean, sensitiveLoggingEnabled: boolean, isNullable: Nullable_1<System_Internal.Boolean>): ColumnModificationParameters;
    new(column: IColumn, originalValue: unknown | null, value: unknown | null, property: IProperty | null, typeMapping: RelationalTypeMapping | null, read: boolean, write: boolean, key: boolean, condition: boolean, sensitiveLoggingEnabled: boolean, isNullable: Nullable_1<System_Internal.Boolean>): ColumnModificationParameters;
    new(entry: IUpdateEntry | null, property: IProperty | null, column: IColumnBase, generateParameterName: Func_1<System_Internal.String>, typeMapping: RelationalTypeMapping, valueIsRead: boolean, valueIsWrite: boolean, columnIsKey: boolean, columnIsCondition: boolean, sensitiveLoggingEnabled: boolean): ColumnModificationParameters;
    new(columnName: string, value: unknown | null, property: IProperty | null, columnType: string | null, typeMapping: RelationalTypeMapping | null, jsonPath: string, read: boolean, write: boolean, key: boolean, condition: boolean, sensitiveLoggingEnabled: boolean, isNullable: Nullable_1<System_Internal.Boolean>): ColumnModificationParameters;
};


export type ColumnModificationParameters = ColumnModificationParameters$instance;

export interface ModificationCommandParameters$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_ModificationCommandParameters: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    get Comparer(): IComparer_1<IUpdateEntry> | null;
    set Comparer(value: IComparer_1<IUpdateEntry> | null);
    DetailedErrorsEnabled: boolean;
    get GenerateParameterName(): Func_1<System_Internal.String> | null;
    set GenerateParameterName(value: Func_1<System_Internal.String> | null);
    get Logger(): IDiagnosticsLogger_1<DbLoggerCategory_Update> | null;
    set Logger(value: IDiagnosticsLogger_1<DbLoggerCategory_Update> | null);
    get Schema(): string | null;
    set Schema(value: string | null);
    SensitiveLoggingEnabled: boolean;
    readonly StoreStoredProcedure: IStoreStoredProcedure | null;
    get Table(): ITable | null;
    set Table(value: ITable | null);
    TableName: string;
    Equals(obj: unknown): boolean;
    Equals(other: ModificationCommandParameters): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const ModificationCommandParameters: {
    new(table: ITable, storeStoredProcedure: IStoreStoredProcedure | null, sensitiveLoggingEnabled: boolean, detailedErrorsEnabled: boolean, comparer: IComparer_1<IUpdateEntry> | null, generateParameterName: Func_1<System_Internal.String> | null, logger: IDiagnosticsLogger_1<DbLoggerCategory_Update> | null): ModificationCommandParameters;
    new(table: ITable, sensitiveLoggingEnabled: boolean, detailedErrorsEnabled: boolean, comparer: IComparer_1<IUpdateEntry> | null, generateParameterName: Func_1<System_Internal.String> | null, logger: IDiagnosticsLogger_1<DbLoggerCategory_Update> | null): ModificationCommandParameters;
};


export type ModificationCommandParameters = ModificationCommandParameters$instance;

export interface NonTrackedModificationCommandParameters$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_NonTrackedModificationCommandParameters: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    get Schema(): string | null;
    set Schema(value: string | null);
    SensitiveLoggingEnabled: boolean;
    get Table(): ITable | null;
    set Table(value: ITable | null);
    TableName: string;
    Equals(obj: unknown): boolean;
    Equals(other: NonTrackedModificationCommandParameters): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const NonTrackedModificationCommandParameters: {
    new(tableName: string, schemaName: string | null, sensitiveLoggingEnabled: boolean): NonTrackedModificationCommandParameters;
    new(table: ITable, sensitiveLoggingEnabled: boolean): NonTrackedModificationCommandParameters;
};


export type NonTrackedModificationCommandParameters = NonTrackedModificationCommandParameters$instance;

export interface AffectedCountModificationCommandBatch$instance extends ReaderModificationCommandBatch {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_AffectedCountModificationCommandBatch: never;

    Consume(reader: RelationalDataReader): void;
    ConsumeAsync(reader: RelationalDataReader, cancellationToken?: CancellationToken): Task;
    ConsumeResultSet(startCommandIndex: int, reader: RelationalDataReader): int;
    ConsumeResultSetAsync(startCommandIndex: int, reader: RelationalDataReader, cancellationToken: CancellationToken): Task_1<System_Internal.Int32>;
    ConsumeResultSetWithRowsAffectedOnly(commandIndex: int, reader: RelationalDataReader): int;
    ConsumeResultSetWithRowsAffectedOnlyAsync(commandIndex: int, reader: RelationalDataReader, cancellationToken: CancellationToken): Task_1<System_Internal.Int32>;
    ThrowAggregateUpdateConcurrencyException(reader: RelationalDataReader, commandIndex: int, expectedRowsAffected: int, rowsAffected: int): void;
    ThrowAggregateUpdateConcurrencyExceptionAsync(reader: RelationalDataReader, commandIndex: int, expectedRowsAffected: int, rowsAffected: int, cancellationToken: CancellationToken): Task;
}


export const AffectedCountModificationCommandBatch: (abstract new(dependencies: ModificationCommandBatchFactoryDependencies, maxBatchSize: Nullable_1<System_Internal.Int32>) => AffectedCountModificationCommandBatch) & {
};


export type AffectedCountModificationCommandBatch = AffectedCountModificationCommandBatch$instance;

export interface ColumnModification$instance extends IColumnModification$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_ColumnModification: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IColumnModification: never;

    readonly Column: IColumnBase | null;
    readonly ColumnName: string;
    readonly ColumnType: string | null;
    readonly Entry: IUpdateEntry | null;
    IsCondition: boolean;
    IsKey: boolean;
    readonly IsNullable: Nullable_1<System_Internal.Boolean>;
    IsRead: boolean;
    IsWrite: boolean;
    readonly JsonPath: string | null;
    readonly OriginalParameterName: string | null;
    get OriginalValue(): unknown | null;
    set OriginalValue(value: unknown | null);
    readonly ParameterName: string | null;
    readonly Property: IProperty | null;
    readonly TypeMapping: RelationalTypeMapping | null;
    readonly UseCurrentValue: boolean;
    readonly UseCurrentValueParameter: boolean;
    readonly UseOriginalValue: boolean;
    readonly UseOriginalValueParameter: boolean;
    readonly UseParameter: boolean;
    get Value(): unknown | null;
    set Value(value: unknown | null);
    AddSharedColumnModification(modification: IColumnModification): void;
    ResetParameterNames(): void;
}


export const ColumnModification: {
    new(columnModificationParameters: ColumnModificationParameters): ColumnModification;
    GetCurrentProviderValue(entry: IUpdateEntry, property: IProperty): unknown | null;
    GetCurrentValue(entry: IUpdateEntry, property: IProperty): unknown | null;
    GetOriginalProviderValue(entry: IUpdateEntry, property: IProperty): unknown | null;
    GetOriginalValue(entry: IUpdateEntry, property: IProperty): unknown | null;
    IsModified(entry: IUpdateEntry, property: IProperty): boolean;
    IsStoreGenerated(entry: IUpdateEntry, property: IProperty): boolean;
    SetStoreGeneratedValue(entry: IUpdateEntry, property: IProperty, value: unknown | null): void;
};


export interface __ColumnModification$views {
    As_IColumnModification(): IColumnModification$instance;
}

export type ColumnModification = ColumnModification$instance & __ColumnModification$views;


export interface EquatableKeyValue_1$instance<TKey extends unknown> {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_EquatableKeyValue_1: never;

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


export const EquatableKeyValue_1: {
    new<TKey extends unknown>(metadata: IAnnotatable, keyValue: TKey | null, keyComparer: IEqualityComparer_1<TKey>): EquatableKeyValue_1<TKey>;
};


export type EquatableKeyValue_1<TKey extends unknown> = EquatableKeyValue_1$instance<TKey>;

export interface ModificationCommand$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_ModificationCommand: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IModificationCommand: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_INonTrackedModificationCommand: never;
    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IReadOnlyModificationCommand: never;

    readonly ColumnModifications: IReadOnlyList_1<IColumnModification>;
    EntityState: EntityState;
    readonly Entries: IReadOnlyList_1<IUpdateEntry>;
    get RowsAffectedColumn(): IColumnBase | null;
    set RowsAffectedColumn(value: IColumnBase | null);
    readonly Schema: string | null;
    readonly StoreStoredProcedure: IStoreStoredProcedure | null;
    readonly Table: ITable | null;
    readonly TableName: string;
    AddColumnModification(columnModificationParameters: ColumnModificationParameters): IColumnModification;
    AddEntry(entry: IUpdateEntry, mainEntry: boolean): void;
    AssertColumnsNotInitialized(): void;
    CreateColumnModification(columnModificationParameters: ColumnModificationParameters): IColumnModification;
    ProcessSinglePropertyJsonUpdate(parameters: ColumnModificationParameters): void;
    PropagateOutputParameters(parameterCollection: DbParameterCollection, baseParameterIndex: int): void;
    PropagateResults(relationalReader: RelationalDataReader): void;
    ToString(): string;
}


export const ModificationCommand: {
    new(modificationCommandParameters: ModificationCommandParameters): ModificationCommand;
    new(modificationCommandParameters: NonTrackedModificationCommandParameters): ModificationCommand;
};


export interface __ModificationCommand$views {
    As_IModificationCommand(): IModificationCommand$instance;
    As_INonTrackedModificationCommand(): INonTrackedModificationCommand$instance;
    As_IReadOnlyModificationCommand(): IReadOnlyModificationCommand$instance;
}

export type ModificationCommand = ModificationCommand$instance & __ModificationCommand$views;


export interface ModificationCommandBatch$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_ModificationCommandBatch: never;

    readonly AreMoreBatchesExpected: boolean;
    readonly ModificationCommands: IReadOnlyList_1<IReadOnlyModificationCommand>;
    readonly RequiresTransaction: boolean;
    Complete(moreBatchesExpected: boolean): void;
    Execute(connection: IRelationalConnection): void;
    ExecuteAsync(connection: IRelationalConnection, cancellationToken?: CancellationToken): Task;
    TryAddCommand(modificationCommand: IReadOnlyModificationCommand): boolean;
}


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


export type ModificationCommandBatch = ModificationCommandBatch$instance;

export interface ModificationCommandBatchFactoryDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_ModificationCommandBatchFactoryDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    CommandBuilderFactory: IRelationalCommandBuilderFactory;
    CurrentContext: ICurrentDbContext;
    Logger: IRelationalCommandDiagnosticsLogger;
    SqlGenerationHelper: ISqlGenerationHelper;
    readonly UpdateLogger: IDiagnosticsLogger_1<DbLoggerCategory_Update>;
    UpdateSqlGenerator: IUpdateSqlGenerator;
    _Clone_$(): ModificationCommandBatchFactoryDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: ModificationCommandBatchFactoryDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const ModificationCommandBatchFactoryDependencies: {
    new(commandBuilderFactory: IRelationalCommandBuilderFactory, sqlGenerationHelper: ISqlGenerationHelper, updateSqlGenerator: IUpdateSqlGenerator, currentContext: ICurrentDbContext, logger: IRelationalCommandDiagnosticsLogger, updateLogger: IDiagnosticsLogger_1<DbLoggerCategory_Update>): ModificationCommandBatchFactoryDependencies;
};


export type ModificationCommandBatchFactoryDependencies = ModificationCommandBatchFactoryDependencies$instance;

export interface ReaderModificationCommandBatch$instance extends ModificationCommandBatch {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_ReaderModificationCommandBatch: never;

    readonly AreMoreBatchesExpected: boolean;
    readonly Dependencies: ModificationCommandBatchFactoryDependencies;
    readonly IsCommandTextEmpty: boolean;
    readonly MaxBatchSize: int;
    readonly ModificationCommands: IReadOnlyList_1<IReadOnlyModificationCommand>;
    readonly ParameterValues: Dictionary_2<System_Internal.String, unknown | null>;
    readonly RelationalCommandBuilder: IRelationalCommandBuilder;
    readonly RequiresTransaction: boolean;
    readonly ResultSetMappings: IList_1<ResultSetMapping>;
    readonly SqlBuilder: StringBuilder;
    get StoreCommand(): RawSqlCommand | null;
    set StoreCommand(value: RawSqlCommand | null);
    readonly UpdateSqlGenerator: IUpdateSqlGenerator;
    AddCommand(modificationCommand: IReadOnlyModificationCommand): void;
    AddParameter(columnModification: IColumnModification): void;
    AddParameters(modificationCommand: IReadOnlyModificationCommand): void;
    Complete(moreBatchesExpected: boolean): void;
    Consume(reader: RelationalDataReader): void;
    ConsumeAsync(reader: RelationalDataReader, cancellationToken?: CancellationToken): Task;
    Execute(connection: IRelationalConnection): void;
    ExecuteAsync(connection: IRelationalConnection, cancellationToken?: CancellationToken): Task;
    IsValid(): boolean;
    RollbackLastCommand(modificationCommand: IReadOnlyModificationCommand): void;
    SetRequiresTransaction(requiresTransaction: boolean): void;
    TryAddCommand(modificationCommand: IReadOnlyModificationCommand): boolean;
}


export const ReaderModificationCommandBatch: (abstract new(dependencies: ModificationCommandBatchFactoryDependencies, maxBatchSize: Nullable_1<System_Internal.Int32>) => ReaderModificationCommandBatch) & {
};


export type ReaderModificationCommandBatch = ReaderModificationCommandBatch$instance;

export interface SingularModificationCommandBatch$instance extends AffectedCountModificationCommandBatch {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_SingularModificationCommandBatch: never;

}


export const SingularModificationCommandBatch: {
    new(dependencies: ModificationCommandBatchFactoryDependencies): SingularModificationCommandBatch;
};


export type SingularModificationCommandBatch = SingularModificationCommandBatch$instance;

export interface UpdateAndSelectSqlGenerator$instance extends UpdateSqlGenerator$instance, IUpdateSqlGenerator$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_UpdateAndSelectSqlGenerator: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IUpdateSqlGenerator: never;

    AppendDeleteAndSelectOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendDeleteOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendDeleteOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int): ResultSetMapping;
    AppendFromClause(commandStringBuilder: StringBuilder, name: string, schema: string | null): void;
    AppendIdentityWhereCondition(commandStringBuilder: StringBuilder, columnModification: IColumnModification): void;
    AppendInsertAndSelectOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendInsertOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendInsertOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int): ResultSetMapping;
    AppendRowsAffectedWhereCondition(commandStringBuilder: StringBuilder, expectedRowsAffected: int): void;
    AppendSelectAffectedCommand(commandStringBuilder: StringBuilder, name: string, schema: string | null, readOperations: IReadOnlyList_1<IColumnModification>, conditionOperations: IReadOnlyList_1<IColumnModification>, commandPosition: int): ResultSetMapping;
    AppendSelectAffectedCountCommand(commandStringBuilder: StringBuilder, name: string, schema: string | null, commandPosition: int): ResultSetMapping;
    AppendSelectCommandHeader(commandStringBuilder: StringBuilder, operations: IReadOnlyList_1<IColumnModification>): void;
    AppendUpdateAndSelectOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendUpdateOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendUpdateOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int): ResultSetMapping;
    AppendWhereAffectedClause(commandStringBuilder: StringBuilder, operations: IReadOnlyList_1<IColumnModification>): void;
    IsIdentityOperation(modification: IColumnModification): boolean;
}


export const UpdateAndSelectSqlGenerator: (abstract new(dependencies: UpdateSqlGeneratorDependencies) => UpdateAndSelectSqlGenerator) & {
};


export interface __UpdateAndSelectSqlGenerator$views {
    As_IUpdateSqlGenerator(): IUpdateSqlGenerator$instance;
}

export type UpdateAndSelectSqlGenerator = UpdateAndSelectSqlGenerator$instance & __UpdateAndSelectSqlGenerator$views;


export interface UpdateSqlGenerator$instance extends IUpdateSqlGenerator$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_UpdateSqlGenerator: never;

    readonly __tsonic_iface_Microsoft_EntityFrameworkCore_Update_IUpdateSqlGenerator: never;

    readonly Dependencies: UpdateSqlGeneratorDependencies;
    readonly SqlGenerationHelper: ISqlGenerationHelper;
    AppendBatchHeader(commandStringBuilder: StringBuilder): void;
    AppendDeleteCommand(commandStringBuilder: StringBuilder, name: string, schema: string | null, readOperations: IReadOnlyList_1<IColumnModification>, conditionOperations: IReadOnlyList_1<IColumnModification>, appendReturningOneClause?: boolean): void;
    AppendDeleteCommandHeader(commandStringBuilder: StringBuilder, name: string, schema: string | null): void;
    AppendDeleteOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendDeleteOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int): ResultSetMapping;
    AppendDeleteReturningOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendInsertCommand(commandStringBuilder: StringBuilder, name: string, schema: string | null, writeOperations: IReadOnlyList_1<IColumnModification>, readOperations: IReadOnlyList_1<IColumnModification>): void;
    AppendInsertCommandHeader(commandStringBuilder: StringBuilder, name: string, schema: string | null, operations: IReadOnlyList_1<IColumnModification>): void;
    AppendInsertOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendInsertOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int): ResultSetMapping;
    AppendInsertReturningOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendNextSequenceValueOperation(commandStringBuilder: StringBuilder, name: string, schema: string | null): void;
    AppendObtainNextSequenceValueOperation(commandStringBuilder: StringBuilder, name: string, schema: string | null): void;
    AppendReturningClause(commandStringBuilder: StringBuilder, operations: IReadOnlyList_1<IColumnModification>, additionalValues?: string | null): void;
    AppendStoredProcedureCall(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendUpdateColumnValue(updateSqlGeneratorHelper: ISqlGenerationHelper, columnModification: IColumnModification, stringBuilder: StringBuilder, name: string, schema: string | null): void;
    AppendUpdateCommand(commandStringBuilder: StringBuilder, name: string, schema: string | null, writeOperations: IReadOnlyList_1<IColumnModification>, readOperations: IReadOnlyList_1<IColumnModification>, conditionOperations: IReadOnlyList_1<IColumnModification>, appendReturningOneClause?: boolean): void;
    AppendUpdateCommandHeader(commandStringBuilder: StringBuilder, name: string, schema: string | null, operations: IReadOnlyList_1<IColumnModification>): void;
    AppendUpdateOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendUpdateOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int): ResultSetMapping;
    AppendUpdateReturningOperation(commandStringBuilder: StringBuilder, command: IReadOnlyModificationCommand, commandPosition: int, requiresTransaction: boolean): ResultSetMapping;
    AppendValues(commandStringBuilder: StringBuilder, name: string, schema: string | null, operations: IReadOnlyList_1<IColumnModification>): void;
    AppendValuesHeader(commandStringBuilder: StringBuilder, operations: IReadOnlyList_1<IColumnModification>): void;
    AppendWhereClause(commandStringBuilder: StringBuilder, operations: IReadOnlyList_1<IColumnModification>): void;
    AppendWhereCondition(commandStringBuilder: StringBuilder, columnModification: IColumnModification, useOriginalValue: boolean): void;
    GenerateNextSequenceValueOperation(name: string, schema: string | null): string;
    GenerateObtainNextSequenceValueOperation(name: string, schema: string | null): string;
    PrependEnsureAutocommit(commandStringBuilder: StringBuilder): void;
}


export const UpdateSqlGenerator: (abstract new(dependencies: UpdateSqlGeneratorDependencies) => UpdateSqlGenerator) & {
    AppendSqlLiteral(commandStringBuilder: StringBuilder, modification: IColumnModification, tableName: string | null, schema: string | null): void;
};


export interface __UpdateSqlGenerator$views {
    As_IUpdateSqlGenerator(): IUpdateSqlGenerator$instance;
}

export type UpdateSqlGenerator = UpdateSqlGenerator$instance & __UpdateSqlGenerator$views;


export interface UpdateSqlGeneratorDependencies$instance {
    readonly __tsonic_type_Microsoft_EntityFrameworkCore_Update_UpdateSqlGeneratorDependencies: never;

    readonly __tsonic_iface_System_IEquatable_1: never;

    SqlGenerationHelper: ISqlGenerationHelper;
    TypeMappingSource: IRelationalTypeMappingSource;
    _Clone_$(): UpdateSqlGeneratorDependencies;
    Equals(obj: unknown | null): boolean;
    Equals(other: UpdateSqlGeneratorDependencies | null): boolean;
    GetHashCode(): int;
    ToString(): string;
}


export const UpdateSqlGeneratorDependencies: {
    new(sqlGenerationHelper: ISqlGenerationHelper, typeMappingSource: IRelationalTypeMappingSource): UpdateSqlGeneratorDependencies;
};


export type UpdateSqlGeneratorDependencies = UpdateSqlGeneratorDependencies$instance;

export abstract class UpdateEntryExtensions$instance {
    static BuildCurrentValuesString(entry: IUpdateEntry, properties: IEnumerable_1<IPropertyBase>): string;
    static BuildOriginalValuesString(entry: IUpdateEntry, properties: IEnumerable_1<IPropertyBase>): string;
    static GetCurrentProviderValue(updateEntry: IUpdateEntry, property: IProperty): unknown | null;
    static GetOriginalProviderValue(updateEntry: IUpdateEntry, property: IProperty): unknown | null;
    static ToDebugString(updateEntry: IUpdateEntry, options?: ChangeTrackerDebugStringOptions, indent?: int): string;
}


export type UpdateEntryExtensions = UpdateEntryExtensions$instance;