/// <reference types="node" />
import { EntityToJson } from "./EntityToJson";
import { IDisposable } from "../../Types/Contracts";
import { SessionInfo, ConcurrencyCheckMode, StoreOptions } from "./IDocumentSession";
import { IMetadataDictionary } from "./IMetadataDictionary";
import { ObjectTypeDescriptor, ServerResponse } from "../../Types";
import { SessionEventsEmitter } from "./SessionEvents";
import { RequestExecutor } from "../../Http/RequestExecutor";
import { IDocumentStore } from "../IDocumentStore";
import { ServerNode } from "../../Http/ServerNode";
import { DocumentsById, EntityInfo } from "./DocumentsById";
import { DocumentInfo } from "./DocumentInfo";
import { DocumentStoreBase } from "../DocumentStoreBase";
import { ICommandData, SaveChangesData } from "../Commands/CommandData";
import { GenerateEntityIdOnTheClient } from "../Identity/GenerateEntityIdOnTheClient";
import { DocumentType } from "../DocumentAbstractions";
import { DocumentsChanges } from "./DocumentsChanges";
import { EventEmitter } from "events";
import { IRavenObject } from "../../Types/IRavenObject";
import { GetDocumentsCommand } from "../Commands/GetDocumentsCommand";
import { DocumentConventions } from "../Conventions/DocumentConventions";
import { JsonSerializer } from "../../Mapping/Json/Serializer";
import { OperationExecutor } from "../Operations/OperationExecutor";
import { IndexBatchOptions, ReplicationBatchOptions } from "./IAdvancedSessionOperations";
import { ILazyOperation } from "./Operations/Lazy/ILazyOperation";
import { TransactionMode } from "./TransactionMode";
import { CounterTracking } from "./CounterInternalTypes";
import { DocumentStore } from "../DocumentStore";
import { SessionOptions } from "./SessionOptions";
import { ClusterTransactionOperationsBase } from "./ClusterTransactionOperationsBase";
import { BatchCommandResult } from "./Operations/BatchCommandResult";
import { Reference } from "../../Utility/Reference";
import { ForceRevisionStrategy } from "./ForceRevisionStrategy";
import { TimeSeriesRangeResult } from "../Operations/TimeSeries/TimeSeriesRangeResult";
import { TimeSeriesEntry } from "./TimeSeries/TimeSeriesEntry";
export declare abstract class InMemoryDocumentSessionOperations extends EventEmitter implements IDisposable, SessionEventsEmitter {
    protected _requestExecutor: RequestExecutor;
    private _operationExecutor;
    protected _pendingLazyOperations: ILazyOperation[];
    protected static _instancesCounter: number;
    private _hash;
    private _disposed;
    protected _jsonSerializer: JsonSerializer;
    private readonly _id;
    get id(): string;
    protected _knownMissingIds: Set<string>;
    private _externalState;
    disableAtomicDocumentWritesInClusterWideTransaction: boolean;
    private _transactionMode;
    get externalState(): Map<string, object>;
    getCurrentSessionNode(): Promise<ServerNode>;
    documentsById: DocumentsById;
    get countersByDocId(): Map<string, CounterTracking>;
    private _countersByDocId;
    private _timeSeriesByDocId;
    get timeSeriesByDocId(): Map<string, Map<string, TimeSeriesRangeResult[]>>;
    readonly noTracking: boolean;
    idsForCreatingForcedRevisions: Map<string, ForceRevisionStrategy>;
    includedDocumentsById: Map<string, DocumentInfo>;
    includeRevisionsByChangeVector: Map<string, DocumentInfo>;
    includeRevisionsIdByDateTimeBefore: Map<string, Map<number, DocumentInfo>>;
    documentsByEntity: DocumentsByEntityHolder;
    deletedEntities: DeletedEntitiesHolder;
    protected _documentStore: DocumentStoreBase;
    private readonly _databaseName;
    private _saveChangesOptions;
    get databaseName(): string;
    get documentStore(): IDocumentStore;
    get requestExecutor(): RequestExecutor;
    get sessionInfo(): SessionInfo;
    get operations(): OperationExecutor;
    private _numberOfRequests;
    get numberOfRequests(): number;
    getNumberOfEntitiesInUnitOfWork(): number;
    get storeIdentifier(): string;
    get conventions(): DocumentConventions;
    maxNumberOfRequestsPerSession: number;
    useOptimisticConcurrency: boolean;
    protected _deferredCommands: ICommandData[];
    deferredCommandsMap: Map<string, ICommandData>;
    get deferredCommands(): ICommandData[];
    get deferredCommandsCount(): number;
    private readonly _generateEntityIdOnTheClient;
    get generateEntityIdOnTheClient(): GenerateEntityIdOnTheClient;
    private readonly _entityToJson;
    get entityToJson(): EntityToJson;
    protected _sessionInfo: SessionInfo;
    protected constructor(documentStore: DocumentStore, id: string, options: SessionOptions);
    protected abstract _generateId(entity: object): Promise<string>;
    getMetadataFor<T extends object>(instance: T): IMetadataDictionary;
    getCountersFor<T extends object>(instance: T): string[];
    getTimeSeriesFor<T extends object>(instance: T): string[];
    private _makeMetadataInstance;
    private _getDocumentInfo;
    protected _assertNoNonUniqueInstance(entity: object, id: string): void;
    getChangeVectorFor<T extends object>(instance: T): string;
    getLastModifiedFor<T extends object>(instance: T): Date;
    isLoaded(id: string): boolean;
    isLoadedOrDeleted(id: string): boolean;
    isDeleted(id: string): boolean;
    getDocumentId(instance: object): string;
    incrementRequestCount(): void;
    checkIfAllChangeVectorsAreAlreadyIncluded(changeVectors: string[]): boolean;
    checkIfRevisionByDateTimeBeforeAlreadyIncluded(id: string, dateTime: Date): boolean;
    checkIfIdAlreadyIncluded(ids: string[], includes: string[]): boolean;
    trackEntity<T extends object>(entityType: ObjectTypeDescriptor<T>, documentFound: DocumentInfo): T;
    trackEntity<T extends object>(entityType: ObjectTypeDescriptor<T>, id: string, document: object, metadata: object, noTracking: boolean): object;
    registerExternalLoadedIntoTheSession(info: DocumentInfo): void;
    private _deserializeFromTransformer;
    registerIncludes(includes: object): void;
    registerRevisionIncludes(revisionIncludes: any[]): void;
    registerMissingIncludes(results: object[], includes: object, includePaths: string[]): void;
    registerMissing(idOrIds: string | string[]): void;
    unregisterMissing(id: string): void;
    registerCounters(resultCounters: object, countersToInclude: {
        [key: string]: string[];
    }): void;
    registerCounters(resultCounters: object, ids: string[], countersToInclude: string[], gotAll: boolean): void;
    private _registerCountersWithIdsList;
    private _registerCountersWithCountersToIncludeObj;
    private _registerCountersInternal;
    private _registerCountersForDocument;
    private _setGotAllInCacheIfNeeded;
    private _setGotAllCountersForDocument;
    private _registerMissingCounters;
    registerTimeSeries(resultTimeSeries: Record<string, Record<string, ServerResponse<TimeSeriesRangeResult>[]>>): void;
    private static _addToCache;
    static addToCache(timeseries: string, from: Date, to: Date, fromRangeIndex: number, toRangeIndex: number, ranges: TimeSeriesRangeResult[], cache: Map<string, TimeSeriesRangeResult[]>, values: TimeSeriesEntry[]): void;
    private static _parseTimeSeriesRangeResult;
    private static _mergeRanges;
    private static _updateExistingRange;
    private _registerMissingCountersWithCountersToIncludeObj;
    private _registerMissingCountersWithIdsList;
    store<TEntity extends object>(entity: TEntity): Promise<void>;
    store<TEntity extends object>(entity: TEntity, id?: string): Promise<void>;
    store<TEntity extends object>(entity: TEntity, id?: string, documentType?: DocumentType<TEntity>): Promise<void>;
    store<TEntity extends object>(entity: TEntity, id?: string, options?: StoreOptions<TEntity>): Promise<void>;
    protected _generateDocumentKeysOnStore: boolean;
    private _storeInternal;
    protected _storeEntityInUnitOfWork(id: string, entity: object, changeVector: string, metadata: object, forceConcurrencyCheck: ConcurrencyCheckMode, documentType: DocumentType): void;
    protected _rememberEntityForDocumentIdGeneration(entity: object): void;
    prepareForSaveChanges(): SaveChangesData;
    validateClusterTransaction(result: SaveChangesData): void;
    protected _updateSessionAfterSaveChanges(result: BatchCommandResult): void;
    onBeforeConversionToDocumentInvoke(id: string, entity: object): void;
    onAfterConversionToDocumentInvoke(id: string, entity: object, document: Reference<object>): void;
    onBeforeConversionToEntityInvoke(id: string, type: DocumentType, document: Reference<object>): void;
    onAfterConversionToEntityInvoke(id: string, document: object, entity: object): void;
    private _prepareCompareExchangeEntities;
    protected abstract _hasClusterSession(): boolean;
    protected abstract _clearClusterSession(): void;
    abstract clusterSession: ClusterTransactionOperationsBase;
    private _newSaveChangesData;
    private _prepareForCreatingRevisionsFromIds;
    private _prepareForEntitiesDeletion;
    private _prepareForEntitiesPuts;
    protected _entityChanged(newObj: object, documentInfo: DocumentInfo, changes: {
        [id: string]: DocumentsChanges[];
    }): boolean;
    private static _throwInvalidModifiedDocumentWithDeferredCommand;
    private static _throwInvalidDeletedDocumentWithDeferredCommand;
    private static _updateMetadataModifications;
    delete(id: string): Promise<void>;
    delete(id: string, expectedChangeVector: string): Promise<void>;
    delete<TEntity extends IRavenObject>(entity: TEntity): Promise<void>;
    private _deleteByEntity;
    private _deleteById;
    defer(...commands: ICommandData[]): void;
    private _deferInternal;
    private _addCommand;
    protected _buildEntityDocInfoByIdHolder<T extends object>(entities: T[]): Map<string, [object, DocumentInfo]>;
    protected _refreshEntities(command: GetDocumentsCommand, idsEntitiesPairs: Map<string, [object, DocumentInfo]>): void;
    protected static _throwCouldNotRefreshDocument(msg: string): void;
    protected _refreshInternal<T extends object>(entity: T, cmd: object, documentInfo: DocumentInfo): void;
    getTrackedEntities(): Map<string, EntityInfo>;
    hasChanges(): boolean;
    evict<T extends object>(entity: T): void;
    clear(): void;
    hasChanged(entity: object): boolean;
    waitForReplicationAfterSaveChanges(): any;
    waitForReplicationAfterSaveChanges(opts: ReplicationBatchOptions): any;
    waitForIndexesAfterSaveChanges(): any;
    waitForIndexesAfterSaveChanges(opts: IndexBatchOptions): any;
    ignoreChangesFor(entity: object): void;
    whatChanged(): {
        [id: string]: DocumentsChanges[];
    };
    private _getAllEntitiesChanges;
    dispose(isDisposing?: boolean): void;
    get transactionMode(): TransactionMode;
    set transactionMode(value: TransactionMode);
    static validateTimeSeriesName(name: string): void;
    static validateIncrementalTimeSeriesName(name: string): void;
    private static _throwNoDatabase;
}
export declare class DocumentsByEntityHolder implements Iterable<DocumentsByEntityEnumeratorResult> {
    private readonly _documentsByEntity;
    private _onBeforeStoreDocumentsByEntity;
    private _prepareEntitiesPuts;
    get size(): number;
    remove(entity: object): void;
    evict(entity: object): void;
    put(entity: object, documentInfo: DocumentInfo): void;
    private _createOnBeforeStoreDocumentsByEntityIfNeeded;
    clear(): void;
    get(entity: object): DocumentInfo;
    [Symbol.iterator](): Iterator<DocumentsByEntityEnumeratorResult>;
    prepareEntitiesPuts(): IDisposable;
}
export interface DocumentsByEntityEnumeratorResult {
    key: object;
    value: DocumentInfo;
    executeOnBeforeStore: boolean;
}
export declare class DeletedEntitiesHolder implements Iterable<DeletedEntitiesEnumeratorResult> {
    private readonly _deletedEntities;
    private _onBeforeDeletedEntities;
    private _prepareEntitiesDeletes;
    isEmpty(): boolean;
    get size(): number;
    add(entity: object): void;
    remove(entity: object): void;
    evict(entity: object): void;
    contains(entity: object): boolean;
    clear(): void;
    [Symbol.iterator](): Iterator<DeletedEntitiesEnumeratorResult>;
    prepareEntitiesDeletes(): IDisposable;
}
export interface DeletedEntitiesEnumeratorResult {
    entity: object;
    executeOnBeforeDelete: boolean;
}
export interface EntityInfoAndResult {
    entity: object;
    info: DocumentInfo;
    result: object;
}