ravendb/dist/commonjs/Documents/Session/ClusterTransactionOperationsBase.d.ts

RavenDB client for Node.js

import { CompareExchangeValue } from "../Operations/CompareExchange/CompareExchangeValue.js";
import { CompareExchangeResultClass } from "../../Types/index.js";
import { DocumentSession } from "./DocumentSession.js";
import { CompareExchangeSessionValue } from "../Operations/CompareExchange/CompareExchangeSessionValue.js";
import { CompareExchangeResultItem } from "../Operations/CompareExchange/CompareExchangeValueResultParser.js";
import { SaveChangesData } from "../Commands/CommandData.js";
export declare class StoredCompareExchange {
    readonly entity: any;
    readonly index: number;
    constructor(index: number, entity: any);
}
export declare abstract class ClusterTransactionOperationsBase {
    protected readonly _session: DocumentSession;
    private readonly _state;
    private readonly _compareExchangeIncludes;
    private _missingDocumentsTooAtomicGuardIndex;
    tryGetMissingAtomicGuardFor(docId: string, changeVectorCallback: (changeVector: string) => void): boolean;
    get numberOfTrackedCompareExchangeValues(): number;
    protected constructor(session: DocumentSession);
    get session(): DocumentSession;
    isTracked(key: string): boolean;
    createCompareExchangeValue<T>(key: string, item: T): CompareExchangeValue<T>;
    deleteCompareExchangeValue(key: string, index: number): void;
    deleteCompareExchangeValue<T>(item: CompareExchangeValue<T>): void;
    clear(): void;
    protected _getCompareExchangeValueInternal<T>(key: string): Promise<CompareExchangeValue<T>>;
    protected _getCompareExchangeValueInternal<T>(key: string, clazz: CompareExchangeResultClass<T>): Promise<CompareExchangeValue<T>>;
    protected _getCompareExchangeValuesInternal<T>(startsWith: string, clazz: CompareExchangeResultClass<T>, start: number, pageSize: number): Promise<{
        [key: string]: CompareExchangeValue<T>;
    }>;
    protected _getCompareExchangeValuesInternal<T>(keys: string[]): Promise<{
        [key: string]: CompareExchangeValue<T>;
    }>;
    protected _getCompareExchangeValuesInternal<T>(keys: string[], clazz: CompareExchangeResultClass<T>): Promise<{
        [key: string]: CompareExchangeValue<T>;
    }>;
    getCompareExchangeValueFromSessionInternal<T>(key: string, notTracked: (value: boolean) => void, clazz: CompareExchangeResultClass<T>): CompareExchangeValue<T>;
    getCompareExchangeValuesFromSessionInternal<T>(keys: string[], notTrackedKeysSetter: (values: Set<string>) => void, clazz: CompareExchangeResultClass<T>): {
        [key: string]: CompareExchangeValue<T>;
    };
    registerMissingCompareExchangeValue(key: string): CompareExchangeSessionValue;
    registerCompareExchangeIncludes(values: Record<string, CompareExchangeResultItem>, includingMissingAtomicGuards: boolean): void;
    registerCompareExchangeValue(value: CompareExchangeValue<any>): CompareExchangeSessionValue;
    protected _registerCompareExchangeInclude(value: CompareExchangeValue<object>): void;
    private static _assertNotAtomicGuard;
    private _tryGetCompareExchangeValueFromSession;
    prepareCompareExchangeEntities(result: SaveChangesData): void;
    updateState(key: string, index: number): void;
}
//# sourceMappingURL=ClusterTransactionOperationsBase.d.ts.map