declare class TypedEvent<T> {
    private readonly _handlers;
    subscribe(handler: (event: T) => void): () => void;
    unsubscribe(handler: (event: T) => void): void;
    emit(event: T): void;
}

interface ITracked {
    tracker: Tracker;
    /** @internal */
    _validate(property: string, errorMessage: string | undefined): void;
    /** @internal */
    _applyValidation(messages: Map<string, string>): void;
    destroy(): void;
}

declare enum PropertyType {
    Boolean = 0,
    String = 1,
    Number = 2,
    Collection = 3,
    Object = 4,
    Date = 5
}

declare class OperationProperties {
    readonly trackedObject: ITracked;
    readonly property: string | undefined;
    readonly type: PropertyType;
    readonly coalesceWithin?: number | undefined;
    constructor(trackedObject: ITracked, property: string | undefined, type: PropertyType, coalesceWithin?: number | undefined);
}

declare class Change {
    readonly number: number;
    readonly redoAction: () => void;
    readonly undoAction: () => void;
    readonly properties: OperationProperties;
    readonly time: Date;
    constructor(number: number, redoAction: () => void, undoAction: () => void, properties: OperationProperties);
}

declare class Operation {
    readonly time: Date;
    readonly actions: Change[];
    private _hasActions;
    get hasActions(): boolean;
    private set hasActions(value);
    add(redoAction: () => void, undoAction: () => void, properties: OperationProperties): void;
    updateOrAdd(redoAction: () => void, undoAction: () => void, properties: OperationProperties): void;
    /**
     * Chains an effect onto the most recent action targeting the same object and
     * property, so it runs right after that action on both undo and redo. The
     * caller guarantees such an action exists.
     */
    attachAfter(properties: OperationProperties, redoEffect: () => void, undoEffect: () => void): void;
    redo(): void;
    undo(): void;
}

declare class TrackedCollection<T> implements Array<T>, ITracked {
    readonly tracker: Tracker;
    private readonly _validator?;
    private _collection;
    private _isValid;
    private _error;
    private readAccess;
    get trakrIsValid(): boolean;
    private set trakrIsValid(value);
    get length(): number;
    get lastItemIndex(): number | undefined;
    get collection(): T[];
    private set collection(value);
    get [Symbol.iterator](): () => ArrayIterator<T>;
    get [Symbol.unscopables](): {
        [x: number]: boolean | undefined;
        length?: boolean | undefined;
        toString?: boolean | undefined;
        toLocaleString?: boolean | undefined;
        pop?: boolean | undefined;
        push?: boolean | undefined;
        concat?: boolean | undefined;
        join?: boolean | undefined;
        reverse?: boolean | undefined;
        shift?: boolean | undefined;
        slice?: boolean | undefined;
        sort?: boolean | undefined;
        splice?: boolean | undefined;
        unshift?: boolean | undefined;
        indexOf?: boolean | undefined;
        lastIndexOf?: boolean | undefined;
        every?: boolean | undefined;
        some?: boolean | undefined;
        forEach?: boolean | undefined;
        map?: boolean | undefined;
        filter?: boolean | undefined;
        reduce?: boolean | undefined;
        reduceRight?: boolean | undefined;
        find?: boolean | undefined;
        findIndex?: boolean | undefined;
        fill?: boolean | undefined;
        copyWithin?: boolean | undefined;
        entries?: boolean | undefined;
        keys?: boolean | undefined;
        values?: boolean | undefined;
        includes?: boolean | undefined;
        flatMap?: boolean | undefined;
        flat?: boolean | undefined;
        at?: boolean | undefined;
        findLast?: boolean | undefined;
        findLastIndex?: boolean | undefined;
        toReversed?: boolean | undefined;
        toSorted?: boolean | undefined;
        toSpliced?: boolean | undefined;
        with?: boolean | undefined;
        [Symbol.iterator]?: boolean | undefined;
        readonly [Symbol.unscopables]?: boolean | undefined;
    };
    readonly changed: TypedEvent<TrackedCollectionChanged<T>>;
    readonly trackedChanged: TypedEvent<TrackedCollectionChanged<T>>;
    [n: number]: T;
    get error(): string | undefined;
    set error(value: string | undefined);
    constructor(tracker: Tracker, items?: T[], _validator?: ((value: T[]) => string | undefined) | undefined);
    /** @internal */
    _validate(): void;
    /** @internal */
    _applyValidation(_messages: Map<string, string>): void;
    splice(start: number, deleteCount: number, ...items: T[]): T[];
    private doSplice;
    private trackRemovedObjectDeletions;
    private trackAddedObjectInsertions;
    private undoSplice;
    reset(newItems: T[]): void;
    reverse(): T[];
    sort(compareFn?: (a: T, b: T) => number): this;
    clear(): void;
    remove(item: T): boolean;
    replace(item: T, replace: T): boolean;
    replaceAt(index: number, replace: T): void;
    pop(): T | undefined;
    push(...items: T[]): number;
    concat(...items: (T | ConcatArray<T>)[]): T[];
    join(separator?: string): string;
    shift(): T | undefined;
    slice(start?: number, end?: number): T[];
    unshift(...items: T[]): number;
    indexOf(searchElement: T, fromIndex?: number): number;
    lastIndexOf(searchElement: T, fromIndex?: number): number;
    every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
    some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
    filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
    find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
    findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
    flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray<U>, thisArg?: This): U[];
    includes(searchElement: T, fromIndex?: number): boolean;
    toString(): string;
    toLocaleString(): string;
    entries(): ArrayIterator<[number, T]>;
    keys(): ArrayIterator<number>;
    values(): ArrayIterator<T>;
    at(index: number): T | undefined;
    fill(value: T, start?: number, end?: number): this;
    copyWithin(target: number, start: number, end?: number): this;
    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
    flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
    findLast(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T | undefined;
    findLastIndex(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): number;
    toReversed(): T[];
    toSorted(compareFn?: (a: T, b: T) => number): T[];
    toSpliced(start: number, deleteCount: number, ...items: T[]): T[];
    with(index: number, value: T): T[];
    first(): T | undefined;
    destroy(): void;
}
declare class TrackedCollectionChanged<T> {
    readonly added: T[];
    readonly removed: T[];
    readonly newCollection: T[];
    constructor(added: T[], removed: T[], newCollection: T[]);
}
declare global {
    interface ArrayIterator<T> extends IterableIterator<T> {
        map<U>(callback: (value: T) => U): ArrayIterator<U>;
        filter(predicate: (value: T) => boolean): ArrayIterator<T>;
        take(count: number): ArrayIterator<T>;
        drop(count: number): ArrayIterator<T>;
        flatMap<U>(callback: (value: T) => U[]): ArrayIterator<U>;
        reduce<U>(callback: (acc: U, value: T) => U, initialValue: U): U;
        toArray(): T[];
        forEach(callback: (value: T) => void): void;
        some(predicate: (value: T) => boolean): boolean;
        every(predicate: (value: T) => boolean): boolean;
        find(predicate: (value: T) => boolean): T | undefined;
    }
}

interface TrackedPropertyChanged {
    property: string;
    oldValue: unknown;
    newValue: unknown;
}
/**
 * What every tracked model has, whichever tracker it belongs to: change
 * events, validation and a stable `trakrId`. Models extend one of its two
 * subclasses — {@link TrackedObject} for an `EventTracker`, or
 * `DirtyTrackedObject` for a `DirtyTracker`.
 */
declare abstract class TrackedObjectBase implements ITracked {
    readonly tracker: Tracker;
    private _validationMessages;
    private _isValid;
    private _validityReleased;
    readonly trakrId: number;
    readonly beforeChange: TypedEvent<TrackedPropertyChanged>;
    readonly afterChange: TypedEvent<TrackedPropertyChanged>;
    readonly trackedChanged: TypedEvent<TrackedPropertyChanged>;
    /** Alias for {@link afterChange}. Retained for backwards compatibility. */
    get changed(): TypedEvent<TrackedPropertyChanged>;
    get validationMessages(): Map<string, string | undefined>;
    private set validationMessages(value);
    get trakrIsValid(): boolean;
    protected set trakrIsValid(value: boolean);
    /**
     * @internal True while this object sits outside its collection on an
     * EventTracker: its validity no longer counts towards `tracker.isValid`.
     */
    get _isValidityReleased(): boolean;
    protected _setIsValid(value: boolean): void;
    protected constructor(tracker: Tracker);
    /** @internal A tracked property of this object was written. */
    _onTrackedWrite(): void;
    /** @internal That write was undone. */
    _onTrackedWriteUndone(): void;
    /**
     * @internal This object left a collection (or a tracked property). It stays
     * registered — undo or a re-add may bring it back — but stops counting
     * towards `tracker.isValid` until it does.
     */
    _markRemoved(): void;
    /** @internal This object was added to a collection (or a tracked property). */
    _markAdded(): void;
    /** @internal */
    _validate(property: string, errorMessage: string | undefined): void;
    /** @internal */
    _applyValidation(messages: Map<string, string>): void;
    destroy(): void;
}

interface ITrackerContext {
    isDirty: boolean;
    isValid: boolean;
    canCommit: boolean;
    canUndo: boolean;
    canRedo: boolean;
    trackedObjects: TrackedObjectBase[];
    undo(): void;
    redo(): void;
    isDirtyChanged: TypedEvent<boolean>;
    canCommitChanged: TypedEvent<boolean>;
    versionChanged: TypedEvent<number>;
}

type PropertyScope = [TrackedObjectBase, string[]];
interface ITrackerDelegate {
    readonly canUndo: boolean;
    readonly canRedo: boolean;
    undo(): void;
    redo(): void;
    readonly isDirtyChanged: TypedEvent<boolean>;
    readonly canCommitChanged: TypedEvent<boolean>;
    readonly versionChanged: TypedEvent<number>;
}
declare class TrackerSession implements ITrackerContext {
    private readonly _tracker;
    private readonly _end;
    private readonly _rollback;
    private readonly _scope;
    private _isDirty;
    constructor(scope: PropertyScope[] | undefined, _tracker: ITrackerDelegate, _end: () => void, _rollback: () => void);
    /** @internal */
    _onWrite(obj: TrackedObjectBase, property: string): void;
    get isDirty(): boolean;
    get isValid(): boolean;
    get canCommit(): boolean;
    get canUndo(): boolean;
    get canRedo(): boolean;
    get trackedObjects(): TrackedObjectBase[];
    undo(): void;
    redo(): void;
    get isDirtyChanged(): TypedEvent<boolean>;
    get canCommitChanged(): TypedEvent<boolean>;
    get versionChanged(): TypedEvent<number>;
    end(): void;
    rollback(): void;
}

/**
 * Shared core of every tracker: reactive change events, validation, sessions and
 * the undo/redo operation stack. Persistence semantics live in the subclasses:
 * {@link DirtyTracker} (batch commit of object state) and {@link EventTracker}
 * (stream of events acknowledged by the server). Cannot be instantiated directly.
 */
declare abstract class Tracker implements ITrackerContext {
    private _currentOperation;
    protected readonly _redoOperations: Operation[];
    protected readonly _undoOperations: Operation[];
    protected _commitStateOperation: Operation | undefined;
    private _isDirty;
    private _canUndo;
    private _canRedo;
    private _suppressTrackingCounter;
    private _currentOperationOwner;
    private _currentOperationPropertyName;
    private _isValid;
    private _canCommit;
    private _trackingIdCounter;
    private _invalidCount;
    private _constructionDepth;
    private _composingBaseIndex;
    private _composingRedoLength;
    private _currentSession;
    protected _version: number;
    _isReplaying: boolean;
    private _pendingRevalidations;
    readonly trackedObjects: TrackedObjectBase[];
    readonly trackedCollections: TrackedCollection<any>[];
    get isDirty(): boolean;
    set isDirty(value: boolean);
    readonly isDirtyChanged: TypedEvent<boolean>;
    get version(): number;
    readonly versionChanged: TypedEvent<number>;
    get isValid(): boolean;
    private set isValid(value);
    readonly isValidChanged: TypedEvent<boolean>;
    get canCommit(): boolean;
    private set canCommit(value);
    readonly canCommitChanged: TypedEvent<boolean>;
    private updateCanCommit;
    get canUndo(): boolean;
    private set canUndo(value);
    get canRedo(): boolean;
    private set canRedo(value);
    /** @internal */
    get _isTrackingSuppressed(): boolean;
    /** @internal */
    get _isConstructing(): boolean;
    /**
     * @internal Throws unless `obj` is the model type this tracker works with
     * (`DirtyTrackedObject` for DirtyTracker, `TrackedObject` for EventTracker).
     */
    abstract _assertAccepts(obj: TrackedObjectBase): void;
    /** Subclass-specific definition of "has unsaved work". */
    protected abstract _computeIsDirty(): boolean;
    /** A write is about to start (`extended` = it coalesces into the existing `op`). */
    protected _onOperationStart(_op: Operation, _extended: boolean): void;
    /** A top-level write finished recording into `op`. */
    protected _onOperationEnd(_op: Operation): void;
    /** `op` was just undone or redone. */
    protected _onReplayed(_op: Operation): void;
    /** Undone operations were dropped from the redo stack and can never be redone. */
    protected _onOperationsDropped(_ops: readonly Operation[]): void;
    /** `tracker.new()` finished constructing `created`. */
    protected abstract _onNewCompleted(created: readonly TrackedObjectBase[]): void;
    /** A session ended: `composed` became the single undo step `result`. */
    protected _onSessionEnded(_composed: readonly Operation[], _result: Operation): void;
    /** A session was rolled back: `reverted` were undone and removed. */
    protected _onSessionRolledBack(_reverted: readonly Operation[]): void;
    constructor();
    /** @internal */
    _trackObject(trackedObject: TrackedObjectBase): void;
    /** @internal */
    _untrackObject(trackedObject: TrackedObjectBase): void;
    /** @internal */
    _trackCollection(trackedCollection: TrackedCollection<any>): void;
    /** @internal */
    _untrackCollection(trackedCollection: TrackedCollection<any>): void;
    /** @internal An object or collection's validity flipped. */
    _onValidityChanged(becameInvalid: boolean): void;
    construct<T>(action: () => T): T;
    new<T>(action: () => T): T;
    withTrackingSuppressed(action: () => void): void;
    beginSuppressTracking(): void;
    endSuppressTracking(): void;
    /** @internal */
    _doAndTrack(redoAction: () => void, undoAction: () => void, properties: OperationProperties): void;
    private revalidateTargeted;
    private isEndingCurrentOperation;
    private isStartingNewOperation;
    private shouldCoalesceChanges;
    private isCoalescibleType;
    private hasLastOperation;
    private lastOperationTargetsSameProperty;
    private lastActionIsRecent;
    /** @internal */
    _nextTrackingId(): number;
    discardPendingChanges(): void;
    getByTrackingId(trackingId: number): TrackedObjectBase | undefined;
    /** @internal */
    _isInUndoStack(op: Operation): boolean;
    /** Runs `action` as a replay (undo/redo/rollback): tracking suppressed, no new ops recorded. */
    protected replay(action: () => void): void;
    /**
     * @internal Chains a side-effect onto the action of the write identified by
     * `properties` in the operation currently being recorded, so it is undone and
     * redone right after that write.
     */
    _recordSideEffect(redoAction: () => void, undoAction: () => void, properties: OperationProperties): void;
    protected reset(): void;
    startSession(scope?: PropertyScope[]): TrackerSession;
    /** Creates the session object returned by `startSession`; DirtyTracker adds `deletedObjects`. */
    protected _createSession(scope: PropertyScope[] | undefined, end: () => void, rollback: () => void): TrackerSession;
    private endComposing;
    private rollbackComposing;
    undo(): void;
    redo(): void;
    revalidate(): void;
}

interface IdAssignment<V = number> {
    trackingId: number;
    value: V;
}
declare function AutoId<This extends object, Value>(_target: undefined, context: ClassFieldDecoratorContext<This, Value>): void;
declare function Id<This extends object, Value>(_target: undefined, context: ClassFieldDecoratorContext<This, Value>): void;
declare function getIdentityProperties(proto: object): string[];
declare function getIdentity(obj: object): unknown;
declare function getIdentityObject(obj: object): Record<string, unknown>;

declare enum State {
    Unchanged = "Unchanged",
    Insert = "Insert",
    Changed = "Changed",
    Deleted = "Deleted"
}

interface StateTarget {
    trakrId: number;
    trakrState: State;
    _setState(value: State): void;
    _setDirtyCounter(value: number): void;
}

/**
 * Base class for models tracked by a {@link DirtyTracker}. Adds batch-save
 * state: `trakrState` (`Insert` / `Changed` / `Deleted` / `Unchanged`),
 * `dirtyCounter` and `isDirty`, maintained by the state machine.
 */
declare abstract class DirtyTrackedObject extends TrackedObjectBase implements StateTarget {
    readonly tracker: DirtyTracker;
    private _dirtyCounter;
    private _state;
    constructor(tracker: DirtyTracker);
    /** What the save layer has to do with this object. */
    get trakrState(): State;
    /** Net count of uncommitted writes: +1 per write, −1 per undo, reset by `onCommit()`. */
    get dirtyCounter(): number;
    get isDirty(): boolean;
    /** @internal */
    _setState(value: State): void;
    /** @internal */
    _setDirtyCounter(value: number): void;
    /** @internal */
    _onTrackedWrite(): void;
    /** @internal */
    _onTrackedWriteUndone(): void;
    /** @internal */
    _onCommitted(lastOp?: Operation, keys?: IdAssignment<unknown>[]): void;
    /** @internal */
    _markRemoved(): void;
    /** @internal */
    _markAdded(): void;
}

/** A {@link TrackerSession} of a `DirtyTracker`, which also reports scoped deletions. */
declare class DirtyTrackerSession extends TrackerSession {
    /** Scoped objects in `Deleted` state. */
    get deletedObjects(): DirtyTrackedObject[];
}

/**
 * Batch-state tracker for Save-button workflows. Object state is the truth:
 * mutations mark objects Insert/Changed/Deleted, `isDirty`/`canCommit` gate the
 * save, and `onCommit()` atomically transitions everything to Unchanged.
 * Undo can cross a commit boundary — undoing a committed change marks the
 * object dirty again so the next save persists the reversal.
 */
declare class DirtyTracker extends Tracker {
    readonly trackedObjects: DirtyTrackedObject[];
    get deletedObjects(): DirtyTrackedObject[];
    /** @internal */
    _assertAccepts(obj: TrackedObjectBase): void;
    getByTrackingId(trackingId: number): DirtyTrackedObject | undefined;
    startSession(scope?: PropertyScope[]): DirtyTrackerSession;
    protected _createSession(scope: PropertyScope[] | undefined, end: () => void, rollback: () => void): DirtyTrackerSession;
    /** Objects built by `tracker.new()` start clean: their constructor writes are not edits. */
    protected _onNewCompleted(created: readonly TrackedObjectBase[]): void;
    protected _computeIsDirty(): boolean;
    onCommit<V = number>(keys?: IdAssignment<V>[]): void;
    private findLastOpTouching;
}

interface GeneratedEvent<TEventType extends string = string, TPayload = Record<string, unknown>> {
    eventType: TEventType;
    payload: TPayload;
    trackingId?: number;
    targetId?: unknown;
}
/** Where an event stands with respect to the server. */
declare enum EventState {
    /** Recorded, not yet acknowledged — send it. */
    NotCommitted = "NotCommitted",
    /** Acknowledged by the server. Permanent: undoing it adds a compensating event. */
    Committed = "Committed",
    /** Undone before it was sent. Never send it; redo returns it to `NotCommitted`. */
    Undone = "Undone"
}
/** One entry of `EventTracker.events`: an event produced by one operation. */
interface TrackedEvent<TEventType extends string = string, TPayload = Record<string, unknown>> extends GeneratedEvent<TEventType, TPayload> {
    /** Unique within the tracker; pass it (or the event) to `onCommit`. */
    readonly eventId: number;
    readonly state: EventState;
    /** Set on compensating events: the `eventId` of the committed event this one reverts. */
    readonly compensates?: number;
}
interface EventLifecycleOptions<TEventType extends string = string> {
    itemAdded?: TEventType;
    itemRemoved?: TEventType;
}

/**
 * Event-stream tracker for autosave workflows over an event-sourced backend.
 *
 * Every operation records the events it produced in {@link events}, each with
 * an `eventId` and a {@link EventState}. Send the `NotCommitted` ones and
 * acknowledge them with `onCommit`. Undoing an unsent event marks it `Undone`
 * (redo brings it back); undoing a committed event keeps it `Committed` and
 * appends a compensating event.
 */
declare class EventTracker extends Tracker {
    readonly trackedObjects: TrackedObject[];
    /** @internal */
    _assertAccepts(obj: TrackedObjectBase): void;
    getByTrackingId(trackingId: number): TrackedObject | undefined;
    private readonly _log;
    private readonly _byId;
    private readonly _ops;
    private _reopened;
    private readonly _creations;
    private _nextEventId;
    private _logChanged;
    /** Fires with {@link events} whenever an event is added, removed, or changes state. */
    readonly eventsChanged: TypedEvent<readonly TrackedEvent[]>;
    /** Every recorded event, oldest first, in all states. */
    get events(): readonly TrackedEvent[];
    /** The events still to be sent: `NotCommitted`, oldest first. */
    get pendingEvents(): TrackedEvent[];
    withContext<T>(ctx: unknown, action: () => T): T;
    protected _computeIsDirty(): boolean;
    /**
     * Marks events as persisted by the server: only the events whose `eventId`
     * is listed become `Committed`. Events recorded meanwhile stay `NotCommitted`.
     *
     * @param eventIds `eventId`s of the events the server persisted.
     * @param keys server-assigned `@AutoId` values, keyed by `trackingId`.
     */
    onCommit<V = number>(eventIds: readonly number[], keys?: IdAssignment<V>[]): void;
    private assignKeys;
    /**
     * Reverts what has not been sent, as far as it can be reverted cleanly:
     * pending compensations are withdrawn (by redoing), operations whose events
     * are all unsent are undone, and the redo stack is dropped. It never forgets
     * an unsent event whose change is still in the objects — e.g. from an
     * operation that is partly committed, or from `tracker.new()` — so those
     * stay pending.
     */
    discardPendingChanges(): void;
    protected _onOperationStart(op: Operation, extended: boolean): void;
    protected _onOperationEnd(op: Operation): void;
    protected _onReplayed(op: Operation): void;
    protected _onOperationsDropped(ops: readonly Operation[]): void;
    protected _onNewCompleted(): void;
    /**
     * An unsent creation event is redundant once the object is reported as added
     * to a collection: the addition carries the object's full snapshot.
     */
    private _dropSupersededCreations;
    protected _onSessionEnded(composed: readonly Operation[], result: Operation): void;
    protected _onSessionRolledBack(reverted: readonly Operation[]): void;
    private _append;
    private _remove;
    private _setState;
    private _notify;
    /** Once an operation's events are recorded, the next operation starts from a clean diff. */
    private _settle;
    private collectPending;
}

/**
 * Base class for models tracked by an {@link EventTracker}. It carries no
 * object state (`trakrState`, `dirtyCounter`): what is pending is the
 * tracker's event list. Models for a `DirtyTracker` extend `DirtyTrackedObject`.
 */
declare abstract class TrackedObject extends TrackedObjectBase {
    readonly tracker: EventTracker;
    constructor(tracker: EventTracker);
}

/**
 * A {@link TrackedObject} (EventTracker model) that aggregates the validity of
 * its children: other tracked objects, collections, and their object items.
 * For a DirtyTracker, use `DirtyTrackedContainer`.
 */
declare abstract class TrackedContainer extends TrackedObject {
    private readonly _kids;
    protected trackChild(child: TrackedObject | TrackedCollection<any>): void;
    protected untrackChild(child: TrackedObject | TrackedCollection<any>): void;
    get trakrIsValid(): boolean;
    set trakrIsValid(value: boolean);
    destroy(): void;
}

/**
 * A {@link DirtyTrackedObject} that aggregates the validity and dirtiness of
 * its children: other tracked objects, collections, and their object items.
 * For an EventTracker, use `TrackedContainer`.
 */
declare abstract class DirtyTrackedContainer extends DirtyTrackedObject {
    private readonly _kids;
    protected trackChild(child: DirtyTrackedObject | TrackedCollection<any>): void;
    protected untrackChild(child: DirtyTrackedObject | TrackedCollection<any>): void;
    get trakrIsValid(): boolean;
    set trakrIsValid(value: boolean);
    get isDirty(): boolean;
    destroy(): void;
}

type ChangeHook<TSelf = any, TValue = any> = (self: TSelf, newValue: TValue, oldValue: TValue) => void;
interface ChangeHooks<TSelf = any, TValue = any> {
    beforeChange?: ChangeHook<TSelf, TValue>;
    afterChange?: ChangeHook<TSelf, TValue>;
}
declare function Tracked(validator?: (self: any, newValue: any) => string | undefined, hooks?: ChangeHooks | ChangeHook, options?: {
    coalesceWithin?: number;
}): {
    <T extends TrackedObjectBase, V>(target: ClassAccessorDecoratorTarget<T, V>, context: ClassAccessorDecoratorContext<T, V>): ClassAccessorDecoratorResult<T, V>;
    <T extends TrackedObjectBase, V>(target: (this: T, value: V) => void, context: ClassSetterDecoratorContext<T, V>): (this: T, value: V) => void;
    <T extends TrackedObjectBase, V>(target: (this: T) => V, context: ClassGetterDecoratorContext<T, V>): (this: T) => V;
};

interface HistoryOptions<TSelf = any, TValue = any> {
    entryFactory: (self: TSelf, newValue: TValue, oldValue: TValue, change: Change, ctx?: unknown) => unknown;
}
type HistoryConfig = boolean | HistoryOptions;
interface EventPropertyOptions {
    eventType?: string;
    history?: HistoryConfig;
    coalesceWithin?: number;
}

interface EventTrackedOptions {
    coalesceWithin?: number;
    eventType?: string;
    history?: HistoryConfig;
}
declare function EventTracked(validator?: (self: any, newValue: any) => string | undefined, hooks?: ChangeHooks | ChangeHook, options?: EventTrackedOptions): {
    <T extends TrackedObject, V>(target: ClassAccessorDecoratorTarget<T, V>, context: ClassAccessorDecoratorContext<T, V>): ClassAccessorDecoratorResult<T, V>;
    <T extends TrackedObject, V>(target: (this: T, value: V) => void, context: ClassSetterDecoratorContext<T, V>): (this: T, value: V) => void;
    <T extends TrackedObject, V>(target: (this: T) => V, context: ClassGetterDecoratorContext<T, V>): (this: T) => V;
};

type CollectionOpKind = "add" | "remove" | "change";
interface CollectionHistoryOptions<T = any> {
    /**
     * Builds one history entry. `op` says what happened to `self`; compensating
     * entries emitted by undo-after-commit carry the inverse kind.
     */
    entryFactory: (self: T, change: Change, ctx: unknown, op: CollectionOpKind) => unknown;
}
type CollectionHistoryConfig = boolean | CollectionHistoryOptions;
interface EventTrackedCollectionOptions<T = any, TEventType extends string = string> extends EventLifecycleOptions<TEventType> {
    eventType?: TEventType;
    history?: CollectionHistoryConfig;
    owner?: {
        object: TrackedObject;
        property: string;
    };
}
/** @internal */
interface CollectionOp {
    op: CollectionOpKind;
    item: TrackedObject;
    identity?: unknown;
    diff?: Record<string, unknown>;
    raw?: unknown;
    snapshot?: Record<string, unknown>;
}
declare class EventTrackedCollection<T, TEventType extends string = string> extends TrackedCollection<T> {
    private readonly _eventOptions;
    private readonly _historyOps;
    private readonly _baselineItems;
    constructor(tracker: EventTracker, items?: T[], validator?: (value: T[]) => string | undefined, options?: EventTrackedCollectionOptions<T, TEventType>);
    /** @internal */
    get _lifecycleOptions(): EventLifecycleOptions<TEventType> | undefined;
    /** @internal */
    get _aggregateOptions(): EventTrackedCollectionOptions<T, TEventType> | undefined;
    /** @internal */
    get _historyOpsList(): CollectionOp[];
    /** @internal Forgets pending ops: current items become the baseline. */
    _clearHistoryOps(): void;
    /** @internal Puts recorded ops back (coalescing reopens them) and undoes their effect on the baseline. */
    _restoreOps(ops: readonly CollectionOp[]): void;
    /** @internal Sets whether `item` counts as already recorded in this collection. */
    _setInBaseline(item: T, present: boolean): void;
    /** @internal */
    _isInBaseline(item: T): boolean;
    /** @internal */
    _baselineListSnapshot(): T[];
    /** @internal */
    _rebaseline(): void;
    private _isAggregateMode;
    private _isHistoryMode;
    private _validateItemHasIdentity;
    private _attachItemChangeWatchers;
    private _recordOp;
    private _buildOp;
    private _recordChangeOpDiff;
}

export { AutoId, type ChangeHook, type ChangeHooks, type CollectionHistoryConfig, type CollectionHistoryOptions, type CollectionOpKind, DirtyTrackedContainer, DirtyTrackedObject, DirtyTracker, DirtyTrackerSession, type EventLifecycleOptions, type EventPropertyOptions, EventState, EventTracked, EventTrackedCollection, type EventTrackedCollectionOptions, type EventTrackedOptions, EventTracker, type GeneratedEvent, type HistoryConfig, type HistoryOptions, type ITracked, Id, type IdAssignment, type PropertyScope, State, Tracked, TrackedCollection, TrackedCollectionChanged, TrackedContainer, type TrackedEvent, TrackedObject, TrackedObjectBase, type TrackedPropertyChanged, Tracker, TrackerSession, TypedEvent, getIdentity, getIdentityObject, getIdentityProperties };