@sheetxl/sdk 0.7.28-beta.4 → 0.8.0-beta.2

package/types/src/transaction/ITransaction.d.ts

@@ -22,7 +22,26 @@ export interface ITransaction {
      *
      * @param options A final description or options to apply on commit.
      */
-    commit<View = any, P = any>(options?: ITransaction.StoreOperationOptions<View, P>): ITransaction;
+    commit<P = any>(options?: ITransaction.StoreOperationOptions<P>): ITransaction;
+    /**
+     * Close the transaction by folding its writes into the commit it opened on, rather than adding
+     * a step to the history.
+     *
+     * @param options A final description or options to apply, as for {@link commit}.
+     *
+     * @remarks
+     * The same fold as {@link IStore.amend}, which names the commit it lands in; this one always
+     * lands in the commit this transaction began from. Reach for `IStore.amend` when the writes
+     * belong to a commit you can name - what a calculation produced, where a listener registered -
+     * and this when they belong to wherever you started: a model folding its own initialization
+     * into the load it is happening during.
+     *
+     * Either way the writes add no undo entry and no audit of their own; they are undone with the
+     * commit they land in. On a nested transaction there is nothing to fold into and this is
+     * {@link commit}: the writes join the operation that is open, which is already not a step of
+     * their own.
+     */
+    amend<P = any>(options?: ITransaction.StoreOperationOptions<P>): ITransaction;
     /**
      * Discard all changes and children transaction changes.
      */
@@ -35,10 +54,29 @@ export interface ITransaction {
      * A unique id for this transaction. This will be the same id for all sub transactions.
      */
     getId(): string;
+    /**
+     * Identifies what a rollback of this transaction undoes on its own.
+     *
+     * @remarks
+     * A root's is its id. A nested transaction has one of its own, unless it was begun as a step
+     * of the one it is nested in ({@link ITransaction.StoreOperationOptions.savepoint}). It is the
+     * key for a copy-on-write structure that is changed in place: a copy taken under one savepoint
+     * is not reachable from a state that outlives that savepoint's rollback.
+     */
+    getSavepointId(): string;
     /**
      * Describes the current transaction.
      */
     getDescription(): string;
+    /**
+     * The operation this transaction was begun for ({@link ITransaction.StoreOperationOptions.operation}),
+     * or `null` when it was begun without one.
+     *
+     * @remarks
+     * Its own, not its root's: a transaction nested in an operation that did not name one of its
+     * own returns `null`. See {@link ICommit.getOperation} for the operation a commit records.
+     */
+    getOperation(): Readonly<ITransaction.Operation> | null;
     /**
      * 0-Based depth of the current transaction. If 0 then it's globally available.
      */
@@ -62,9 +100,37 @@ export interface ITransaction {
      */
     getStates(): Map<string, any>;
     /**
-     * Returns the view associated with this transaction.
+     * Reads an intent recorded on the root of this transaction.
+     *
+     * @param key Names the intent. Owned by whoever records it.
+     *
+     * @see
+     * {@link setIntent}
+     */
+    getIntent<T = any>(key: string): T | undefined;
+    /**
+     * Records an intent on the root of this transaction: something to do once the operation
+     * completes, rather than a change to the state.
+     *
+     * @param key Names the intent. Owned by whoever records it.
+     * @param value The intent, or a function of the intent currently recorded under `key`.
+     *
+     * @remarks
+     * An intent is data - coords, ids and strings, never a model or a view. It is recorded on
+     * the **root**, so every nested transaction of an operation writes the same bag and a batch
+     * of N operations resolves one set of intents rather than N. It travels on the commit
+     * ({@link ICommit.getIntents}) and so is available again on undo and redo.
+     *
+     * The store gives a key no meaning and no merge rule beyond last-write-wins. An intent that
+     * accumulates - a union of ranges, say - passes a function and merges its own way. The write is
+     * kept, so an amend replays it onto the commit it folds into: the accumulating writer runs a
+     * second time, handed the TARGET's value, and the union spans both. What this transaction
+     * itself holds under the key stays its own contribution, which is what it announces. A writer
+     * must therefore produce a new value rather than mutate the one it is handed.
      */
-    getView(): Record<string, any> | null;
+    setIntent<T = any>(key: string, value: T | ((prev: T | undefined) => T)): void;
+    /** For runtime type checking. */
+    readonly isITransaction: true;
 }
 /**
  * {@inheritDoc ITransaction}
@@ -179,6 +245,13 @@ export declare namespace ITransaction {
          * It is possible that a batch operation was used to create the commit.
          */
         getOperation(): Readonly<Operation>;
+        /**
+         * The intents recorded on the commit, keyed by name. Empty if it recorded none.
+         *
+         * @see
+         * {@link ITransaction.setIntent}
+         */
+        getIntents(): Readonly<Record<string, any>>;
     }
     /**
      * When the first transaction this will contain the name of parameters of the input
@@ -197,15 +270,6 @@ export declare namespace ITransaction {
         params?: PARAMS;
     }
     interface RestoreOptions {
-        /**
-         * If provided restore will only select if the view matches the id.
-         *
-         * @defaultValue undefined - Any view will be selected.
-         *
-         * @remarks
-         * This is used for collaboration.
-         */
-        viewId?: string;
         /**
          * If true will force the restore even if there are open transactions.
          *
@@ -257,7 +321,7 @@ export declare namespace ITransaction {
          * @param stateId The store-issued record id ({@link create}).
          * @param listener
          */
-        addStateListener<STATE = any, VIEW = any>(stateId: string, listener: ITransaction.IStateListener<STATE, VIEW>): IListener.Remove;
+        addStateListener<STATE = any>(stateId: string, listener: ITransaction.IStateListener<STATE>): IListener.Remove;
         /**
          * Returns the last commits of commits.
          * @param commitId The commit id to start from.
@@ -294,18 +358,51 @@ export declare namespace ITransaction {
          */
         isOpenTransaction(): boolean;
         /**
-         * Returns the current view associated with the entire commit.
+         * Returns `true` while a {@link restore} or {@link revert} is being delivered to its
+         * listeners.
          *
          * @remarks
-         * Will return `null` if there is no open transaction.
+         * No transaction is open then, but the store is mid-change: a listener that acts on what it
+         * hears (a transactional emitter listener, a model re-deriving from the restored snapshot)
+         * needs to know that the change it is hearing about is a restore, not an operation.
          */
-        getPendingView(): Record<string, any> | null;
+        isRestoring(): boolean;
+        /**
+         * The root transaction of the operation that is open.
+         *
+         * @remarks
+         * `null` if none is. What it is for is reaching the operation from outside the call that
+         * began it - a model asked to record an intent on whatever is open rather than being handed
+         * the transaction. Writes made through it join that operation.
+         */
+        getPendingTransaction(): ITransaction | null;
+        /**
+         * The innermost open transaction: the one a transaction begun now would nest in.
+         *
+         * @remarks
+         * `null` if none is open. The root of the operation is {@link getPendingTransaction}.
+         */
+        getCurrentTransaction(): ITransaction | null;
         /**
          * Returns the current state associated to a model for the current transaction or globally if there are no open transactions.
          *
          * @param stateId The store-issued record id ({@link create}).
          */
         getState<STATE = any>(stateId: string): Readonly<STATE>;
+        /**
+         * Returns the state a record held as of a commit.
+         *
+         * @param commitId The commit whose snapshot to read.
+         * @param stateId The store-issued record id ({@link create}).
+         *
+         * @remarks
+         * The commit's snapshot, not the current state: what a derived write that lands late - a
+         * calculation's compile landing in the commit that entered a formula ({@link amend}) - reads
+         * so that it sees the inputs as they were when the operation was made, whatever has changed
+         * since. `undefined` when the store no longer holds the commit, or the record did not exist
+         * at it.
+         */
+        getStateAt<STATE = any>(commitId: string, stateId: string): Readonly<STATE> | undefined;
         /**
          * Returns the version id of a record at the current commit.
          *
@@ -333,6 +430,36 @@ export declare namespace ITransaction {
          * their own internal transactions.
          */
         doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): Promise<R> | R;
+        /**
+         * Fold a set of writes into an existing commit, by id, without a log entry.
+         *
+         * @param commitId The commit the writes belong to.
+         * @param callback Performs the writes, handed the commit they fold into (its intents are
+         * what an amend reads). Runs synchronously; whatever it commits joins the target rather than
+         * becoming a commit of its own.
+         *
+         * @remarks
+         * An amend is how derived data lands: what a calculation produced for a commit, or a listener
+         * registration that must never read as an edit. It is not a step in the history:
+         * * it adds no commit and fires no {@link IListeners.onCommitChange} / {@link IListeners.onCommitEnd},
+         *   so the undo manager never sees it;
+         * * it leaves the tip where it is and prunes no redo branch, so it may target a commit the
+         *   store has been restored to;
+         * * its intent writes are replayed onto the target, so an undo of that commit replays them
+         *   and an accumulating {@link ITransaction.setIntent} writer unions with what the target
+         *   already held;
+         * * state listeners are told what the amend recorded, not what the target holds.
+         *
+         * The writes read from and land in the named commit's own snapshot, whichever commit the
+         * store is at, and later snapshots are not touched: a later commit answers for its own
+         * writes. That is the fold for a result computed against a snapshot, a calculation's answer
+         * to a request made at that commit. A target that is not the current commit notifies no
+         * state listener; the current state did not change. A target the store no longer has folds
+         * into the current commit. Called while a transaction is open, the callback runs inside it
+         * and its writes land wherever that operation's commit does: an amend cannot re-target an
+         * operation in progress.
+         */
+        amend<R>(commitId: string, callback: (commit: ITransaction.ICommit) => R): R;
         /**
          * Create a record, minting its stable state id. The opposite of {@link remove}.
          *
@@ -370,8 +497,8 @@ export declare namespace ITransaction {
          */
         restore(commitId: string, options?: ITransaction.RestoreOptions): ITransaction.ICommit;
         /**
-         * Revert is similar to restore in that it moves the state but it applies view
-         * updates in reverse order.
+         * Revert is similar to restore in that it moves the state, but it replays the commit's
+         * intents in reverse - an undo lands where the operation began rather than where it ended.
          *
          * @param commitId
          * @param options
@@ -405,12 +532,47 @@ export declare namespace ITransaction {
          * * A restore/revert will trigger this event.
          */
         onCommitEnd?(commit: ITransaction.ICommit): void;
+        /**
+         * Called after an amend has landed in the commit it targets ({@link IStore.amend},
+         * {@link ITransaction.amend}).
+         *
+         * @param commit The commit that was amended.
+         *
+         * @remarks
+         * The counterpart of {@link onCommitEnd} for a change that is not a commit of its own: the
+         * history did not move, but the current snapshot did, and a listener deferring work until
+         * the store has settled needs to hear it.
+         */
+        onAmendEnd?(commit: ITransaction.ICommit): void;
         /**
          * Called if the commit changes for any reason.
          *
          * @param commit
          */
         onCommitChange?(commit: ITransaction.ICommit): void;
+        /**
+         * Called when the root transaction closes, whether it committed or rolled back.
+         *
+         * @param commit The commit handle.
+         * @param isRollback `true` if the transaction was rolled back.
+         * @param isElided `true` if the root wrote nothing and no commit will land.
+         *
+         * @remarks
+         * Called synchronously, once per operation, after the last nested transaction has closed and
+         * before the commit reaches the log. This is where an operation's intents
+         * ({@link ITransaction.setIntent}) are resolved: no transaction is open, so the work is not
+         * part of the commit, and the depth a nested operation ran at cannot make it fire early.
+         *
+         * A commit that wrote nothing is elided but still closes, so this still fires - and `isElided`
+         * is the only warning a listener gets that {@link onCommitEnd} is NOT coming. An amend closes
+         * here too, with `isAmend`: the id it closes under never lands, its writes fold into another
+         * commit ({@link onAmendEnd}). The three
+         * outcomes are distinct and a listener holding work until the operation settles has to tell
+         * them apart: a rollback (`isRollback`) discards what the operation announced, a landing
+         * commit releases it at {@link onCommitEnd}, and an elided root releases it here, because
+         * nothing further will happen.
+         */
+        onCommitClose?(commit: ITransaction.ICommit, isRollback: boolean, isElided?: boolean, isAmend?: boolean): void;
     }
     /**
      * A source of **durable-commit** notifications: something that announces when a store's committed
@@ -465,30 +627,31 @@ export declare namespace ITransaction {
             onCommit?(event: ITransaction.ICommitSource.CommitEvent): void;
         }
     }
-    interface IStateListener<STATE = any, VIEW = any> {
+    interface IStateListener<STATE = any> {
         /**
          * Called synchronously at the beginning of a transaction before a record is changed.
          *
          * @remarks
          * If this throws an exception then all records within the transaction will not
-         * be applied.
+         * be applied. `intents` are the record's so far: what the operation has declared about
+         * itself by the time it commits (see {@link ITransaction.setIntent}).
          */
-        onBeforeCommitStart?(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
+        onBeforeCommitStart?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>): void;
         /**
          * Called during a transaction.
          *
          * @remarks
-         * This is when changes should be applied. The view will only be provided if restore is used.
+         * This is when changes should be applied.
          */
-        onBeforeCommitEnd?(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
+        onBeforeCommitEnd?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>): void;
         /**
          * Called after the transaction. This is generally used for cleanup or ui notification.
          */
-        onAfterStateChange?(state: STATE, view: VIEW, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean): void;
+        onAfterStateChange?(state: STATE, commit: ITransaction.ICommit, isRevert: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>): void;
         /**
          * Called if the restore or revert is called. This is called asynchronously As should only have passive actions.
          */
-        onRestoreOrRevert?(state: STATE, view: VIEW, commit: ITransaction.ICommit, isUndo: boolean): void;
+        onRestoreOrRevert?(state: STATE, commit: ITransaction.ICommit, isUndo: boolean, isRestore: boolean, intents: Readonly<Record<string, any>>): void;
         /**
          * Called when a model is removed from the transaction.
          */
@@ -556,10 +719,53 @@ export declare namespace ITransaction {
          */
         expectedCommitId?: string;
     }
+    /**
+     * Callbacks a transaction is begun with, called by the store as the transaction and the
+     * operation it belongs to settle.
+     *
+     * @remarks
+     * A nested transaction is a savepoint: committing it merges its writes into its parent, where
+     * they can still be rolled back with an outer transaction. So the outcome hooks report the
+     * OPERATION's outcome - {@link onCommit} once the root lands, {@link onRollback} when this
+     * transaction or any one it is nested in rolls back - and only one of them is ever called.
+     */
+    interface Hooks {
+        /**
+         * Make the writes the caller holds for this transaction, into it.
+         *
+         * @remarks
+         * The caller holds writes to make them together; the store calls this whenever something
+         * needs them made: before another transaction begins inside this one, before this one
+         * commits, and before a read of a record the writes change ({@link writes}). A flush writes
+         * by beginning transactions inside this one; those do not flush it again.
+         */
+        flush?(): void;
+        /**
+         * The records {@link flush} writes: a read of one from the store ({@link IStore.getState})
+         * flushes first, so a reader never sees them without the held writes.
+         *
+         * @remarks
+         * Only the records the held writes change - a reader of anything else, including the writer
+         * itself deciding what to hold, reads as it would. A read made through a transaction
+         * ({@link ITransaction.getState}) sees that transaction and does not flush.
+         */
+        writes?: readonly string[];
+        /**
+         * Called once the operation this transaction belongs to has landed.
+         *
+         * @param commit The root's commit. An operation that wrote nothing is elided but still counts
+         * as landed.
+         */
+        onCommit?(commit: ITransaction.ICommit): void;
+        /**
+         * Called when this transaction, or any transaction it is nested in, rolls back.
+         */
+        onRollback?(): void;
+    }
     /**
      * Options for operations with the store.
      */
-    interface StoreOperationOptions<VIEW = any, PARAMS = any> extends OperationOptions {
+    interface StoreOperationOptions<PARAMS = any> extends OperationOptions, Hooks {
         /**
          * If set to `true`, prevents further transactions from being pushed onto the stack
          * until the current transaction is complete. Once the current transaction is either
@@ -569,16 +775,14 @@ export declare namespace ITransaction {
          */
         preventFurtherTransactions?: boolean;
         /**
-         * If set to `true`, The commit will not create a new snapshot but instead merge with the existing.
-         *
-         * @defaultValue false
+         * `false` begins a nested transaction as a step of the one it is nested in: it shares that
+         * one's {@link ITransaction.getSavepointId}, so structures the two change in place are the
+         * same copies. For a transaction that wraps one write. A rollback of it alone does not
+         * restore what it changed in place.
          *
-         * @remarks
-         * * Ths is used for internal listeners and historical corrections.
-         * * This is only read for the top transaction.
-         * * This should generally be avoided as the audits and history are lost.
+         * @defaultValue true
          */
-        forceAmend?: boolean;
+        savepoint?: boolean;
         /**
          * Stored with the commit.
          */
@@ -587,8 +791,6 @@ export declare namespace ITransaction {
          * Used to record audit points.
          */
         operation?: ITransaction.Operation<PARAMS>;
-        viewAfter?: VIEW | ((prev: VIEW) => VIEW);
-        viewBefore?: VIEW | ((prev: VIEW) => VIEW);
     }
 }
 //# sourceMappingURL=ITransaction.d.ts.map

package/types/src/transaction/Transaction.d.ts

@@ -24,14 +24,15 @@ interface CommitRecord {
     author?: any;
     states: Map<string, any>;
     operation?: ITransaction.Operation<any>;
-    viewBefore?: Record<string, any> | null;
-    viewAfter?: Record<string, any> | null;
+    intents: Record<string, any>;
+    intentWrites: [string, any][];
     previousId?: string | null;
     version: number;
 }
 interface CommitContainer {
     record: CommitRecord;
     commit: ITransaction.ICommit;
+    amendOf?: string;
 }
 /**
  * Events are never fired on sub transactions. Only when making changes to the root
@@ -43,7 +44,7 @@ export declare class TransactionStore implements ITransaction.IStore {
     protected _listenersState: Map<any, Set<ITransaction.IStateListener>>;
     protected _commits: Map<string, CommitContainer>;
     protected _transactionStack: AbstractTransaction[];
-    protected _transactionOpen: boolean;
+    protected _restoring: boolean;
     protected _locked: boolean;
     protected _isSync: boolean;
     protected _isTransient: boolean;
@@ -70,6 +71,7 @@ export declare class TransactionStore implements ITransaction.IStore {
      * branch is never reissued.
      */
     protected _versionCounter: number;
+    protected _flushOnRead: number;
     constructor(options?: ITransaction.StoreConstructorOptions);
     /**
      * Sets the transaction store to be synchronous or asynchronous.
@@ -86,10 +88,26 @@ export declare class TransactionStore implements ITransaction.IStore {
     getCommitCount(): number;
     /** {@inheritDoc ITransaction.IStore.isOpenTransaction} */
     isOpenTransaction(): boolean;
-    /** {@inheritDoc ITransaction.IStore.getView} */
-    getPendingView(): Record<string, any> | null;
+    /** {@inheritDoc ITransaction.IStore.isRestoring} */
+    isRestoring(): boolean;
+    /** {@inheritDoc ITransaction.IStore.getPendingTransaction} */
+    getPendingTransaction(): ITransaction | null;
+    /** {@inheritDoc ITransaction.IStore.getCurrentTransaction} */
+    getCurrentTransaction(): ITransaction | null;
+    /** {@inheritDoc ITransaction.IStore.amend} */
+    amend<R>(commitId: string, callback: (commit: ITransaction.ICommit) => R): R;
+    /**
+     * Fold the tip commit into the one before it: its snapshot becomes that commit's, its intents
+     * merge in, and it leaves the log. For a store mirroring a history in which the tip's id never
+     * landed (an amended or elided root). `false` when there is nothing to fold, or a transaction
+     * is open.
+     * @internal
+     */
+    _squashTip(mergeIntents: (into: Record<string, any>, from: Record<string, any>) => Record<string, any>): boolean;
     /** {@inheritDoc ITransaction.IStore.create} */
     create<STATE = any>(initial?: Readonly<STATE>): string;
+    /** {@inheritDoc ITransaction.IStore.getStateAt} */
+    getStateAt<STATE = any>(commitId: string, stateId: string): Readonly<STATE> | undefined;
     /** {@inheritDoc ITransaction.IStore.getState} */
     getState<STATE = any>(stateId: string): Readonly<STATE>;
     /** {@inheritDoc ITransaction.IStore.getCurrentCommit} */
@@ -124,26 +142,88 @@ export declare class TransactionStore implements ITransaction.IStore {
     /** {@inheritDoc ITransaction.IStore.addListener} */
     addListener(listener: ITransaction.IListeners): IListener.Remove;
     /** {@inheritDoc ITransaction.IStore.addStateListener} */
-    addStateListener<State = any, View = any>(stateId: string, listener: ITransaction.IStateListener<State, View>): IListener.Remove;
+    addStateListener<State = any>(stateId: string, listener: ITransaction.IStateListener<State>): IListener.Remove;
     protected dispatchEvents(dispatcher: () => void, async?: boolean): void | Promise<any>;
-    protected _commitRecord(container: CommitContainer, states: Map<any, any>, forceAmend: boolean): void;
-    _notifyStates(event: keyof ITransaction.IStateListener, container: CommitContainer, states: Map<any, any>, view?: Record<string, any> | null, isRevert?: boolean, isRestore?: boolean, async?: boolean): void;
-    _notify(event: keyof ITransaction.IListeners, commit: ITransaction.ICommit, async?: boolean): void | Promise<any>;
+    /**
+     * Land a sealed root record: as a new commit, or, when `amendOf` names a commit, folded into
+     * that one.
+     *
+     * @remarks
+     * An amend is not a log entry. It writes the states it produced into the current snapshot
+     * and folds its intents into the commit it targets, and nothing else moves: no
+     * `onCommitChange` / `onCommitEnd`, the tip stays, no redo branch is pruned. State listeners
+     * are told what the amend recorded, not what its target holds.
+     *
+     * A target the store no longer has (trimmed, or on a pruned redo branch) folds into the
+     * current commit. A target that is not the current commit takes the amend's intents only:
+     * the states were computed against the current snapshot and belong to it.
+     */
+    protected _commitRecord(container: CommitContainer, states: Map<any, any>, amendOf: string | null): void;
+    _notifyStates(event: keyof ITransaction.IStateListener, container: CommitContainer, states: Map<any, any>, isRevert?: boolean, isRestore?: boolean, async?: boolean, source?: CommitContainer): void;
+    protected _notifyClose(commit: ITransaction.ICommit, isRollback: boolean, isElided?: boolean, isAmend?: boolean): void;
+    _notify(event: Exclude<keyof ITransaction.IListeners, 'onCommitClose'>, commit: ITransaction.ICommit, async?: boolean): void | Promise<any>;
 }
 declare abstract class AbstractTransaction implements ITransaction {
     protected _store: TransactionStore;
     protected _states: Map<string, any>;
     protected _description: string;
+    protected _operation: Readonly<ITransaction.Operation> | null;
     protected _meta: Record<string, string>;
     protected _children: Set<AbstractTransaction>;
     protected _depth: number;
     protected _descriptions?: string[];
     protected _container: CommitContainer;
     protected _closed: boolean;
+    protected _isAmend: boolean;
     protected _readOnly: boolean;
+    protected _hooks: ITransaction.Hooks | null;
+    protected _flushing: boolean;
+    protected _outcomes: ITransaction.Hooks[] | null;
     constructor(store: TransactionStore, container: CommitContainer, options: ITransaction.StoreOperationOptions | string | undefined);
-    /** {@inheritDoc ITransaction.getView} */
-    getView(): Record<string, any> | null;
+    /** @internal Whether a read of some record flushes this transaction. */
+    _isFlushedOnRead(): boolean;
+    /** @internal Whether a read of `stateId` flushes this transaction. */
+    _isFlushedBy(stateId: string): boolean;
+    /**
+     * Calls the `flush` hook, unless it is running: its writes begin transactions inside this one.
+     * @internal
+     */
+    _flush(): void;
+    /**
+     * Commits the transactions still open inside this one, then flushes this one: after it, every
+     * write of this transaction has been made.
+     * @internal
+     */
+    protected _settle(options?: ITransaction.StoreOperationOptions): void;
+    /** @internal A committed child's outcome hooks, now waiting on this transaction's outcome. */
+    _adoptOutcomes(child: AbstractTransaction): void;
+    /** @internal Tells the outcome hooks waiting on this transaction how the operation ended. */
+    protected _notifyOutcome(commit: ITransaction.ICommit | null): void;
+    /**
+     * The commit this transaction is writing into.
+     * @internal
+     */
+    _getCommit(): ITransaction.ICommit;
+    /**
+     * Whether this closed without writing anything, so no commit will land.
+     *
+     * @remarks
+     * Only a root can elide, and only `RootTransaction` overrides this — a nested transaction
+     * closing says nothing about the operation's outcome.
+     * @internal
+     */
+    _isElided(): boolean;
+    /**
+     * Name the commit this root folds into when it commits. See `IStore.amend`.
+     * @internal
+     */
+    _setAmendOf(commitId: string): void;
+    /** @internal Whether this root closes by folding into another commit: its own id never lands. */
+    _isAmendClose(): boolean;
+    /** {@inheritDoc ITransaction.getIntent} */
+    getIntent<T = any>(key: string): T | undefined;
+    /** {@inheritDoc ITransaction.setIntent} */
+    setIntent<T = any>(key: string, value: T | ((prev: T | undefined) => T)): void;
     /** {@inheritDoc ITransaction.getState} */
     abstract getState<STATE = any>(model: any): STATE;
     /** {@inheritDoc ITransaction.rollback} */
@@ -152,10 +232,14 @@ declare abstract class AbstractTransaction implements ITransaction {
     abstract getParent(): ITransaction;
     /** {@inheritDoc ITransaction.getId} */
     abstract getId(): string;
+    /** {@inheritDoc ITransaction.getSavepointId} */
+    abstract getSavepointId(): string;
     /** {@inheritDoc ITransaction.getDepth} */
     getDepth(): number;
     /** {@inheritDoc ITransaction.getDescription} */
     getDescription(): string;
+    /** {@inheritDoc ITransaction.getOperation} */
+    getOperation(): Readonly<ITransaction.Operation> | null;
     /** {@inheritDoc ITransaction.getStates} */
     getStates(): Map<any, any>;
     /** {@inheritDoc ITransaction.beginTransaction} */
@@ -167,6 +251,8 @@ declare abstract class AbstractTransaction implements ITransaction {
     isReadOnly(): boolean;
     /** {@inheritDoc ITransaction.updateState} */
     updateState<STATE = any>(stateId: string, state: Readonly<Partial<STATE>> | ((prev: Readonly<STATE>) => Readonly<STATE>)): STATE;
+    /** {@inheritDoc ITransaction.amend} */
+    amend(options?: ITransaction.StoreOperationOptions): ITransaction;
     /** {@inheritDoc ITransaction.commit} */
     commit(options?: ITransaction.StoreOperationOptions): ITransaction;
     /** {@inheritDoc ITransaction.isClose} */
@@ -179,6 +265,8 @@ declare abstract class AbstractTransaction implements ITransaction {
      */
     _purgeState(id: string): void;
     protected _mergeStates(statesChild: Map<string, any>): Map<string, any> | undefined;
+    /** {@inheritDoc ITransaction.isITransaction} */
+    get isITransaction(): true;
 }
 export {};
 //# sourceMappingURL=Transaction.d.ts.map