@sheetxl/sdk 0.7.27 → 0.7.28-beta.2

package/types/src/theme/ThemeCollection.d.ts

@@ -0,0 +1,62 @@
+import { IColor } from '../color';
+import { ITheme } from './ITheme';
+import { IThemeCollection } from './IThemeCollection';
+export declare class Theme implements ITheme {
+    private _name;
+    private _colors;
+    private _fonts;
+    private _schemeLookup;
+    private _colorMap;
+    private _builtInID;
+    private _delegate;
+    private _formatSchemeXml;
+    private _fillStyleLst;
+    private _lnStyleLst;
+    private _effectStyleLst;
+    private _bgFillStyleLst;
+    private _cacheColors;
+    /** System epoch at which `_cacheColors` was populated (for host-theme invalidation). */
+    private _cacheEpoch;
+    constructor(json: ITheme.JSON | null, delegate?: ITheme | null, builtIn?: number | null);
+    get builtInID(): number | null;
+    /** {@inheritDoc ITheme.getName} */
+    getName(): string;
+    /** {@inheritDoc ITheme.isCustom} */
+    isCustom(): boolean;
+    /** {@inheritDoc ITheme.getColorScheme} */
+    getColorScheme(): ITheme.IColorScheme;
+    /** {@inheritDoc ITheme.getFontScheme} */
+    getFontScheme(): ITheme.IFontScheme;
+    /** {@inheritDoc ITheme.schemeLookup} */
+    schemeLookup(): IColor.SchemeLookup;
+    /** {@inheritDoc ITheme.parseColor} */
+    parseColor(str: string): IColor;
+    /** {@inheritDoc ITheme.toJSON} */
+    toJSON(): ITheme.JSON;
+}
+/**
+ * Collection of themes
+ */
+export declare class ThemeCollection implements IThemeCollection {
+    private _customMap;
+    private _defaultTheme;
+    private _isReadOnly;
+    constructor(_json?: IThemeCollection.JSON | null, isReadOnly?: boolean);
+    /** {@inheritDoc IThemeCollection.getDefaultTheme} */
+    getDefaultTheme(): ITheme;
+    /** {@inheritDoc IThemeCollection.setDefaultTheme} */
+    setDefaultTheme(theme: ITheme): ITheme;
+    /** {@inheritDoc IThemeCollection.getByName} */
+    getByName(name: string): ITheme | null;
+    /** {@inheritDoc ICollection.[Symbol.iterator]} */
+    [Symbol.iterator](): IterableIterator<ITheme>;
+    /** {@inheritDoc IThemeCollection.getByName} */
+    getItems(options?: IThemeCollection.GetItemsOptions): ITheme[];
+    /** {@inheritDoc IThemeCollection.getCount} */
+    getCount(): number;
+    /** {@inheritDoc IThemeCollection.setCustomTheme} */
+    setCustomTheme(theme: ITheme): ITheme | null;
+    /** {@inheritDoc IThemeCollection.deleteCustomTheme} */
+    deleteCustomTheme(theme: ITheme | string): ITheme | null;
+}
+//# sourceMappingURL=ThemeCollection.d.ts.map

package/types/src/theme/_BuiltInColorSchemes.d.ts

@@ -0,0 +1,3 @@
+declare const _BuiltInColorSchemes: string[][];
+export default _BuiltInColorSchemes;
+//# sourceMappingURL=_BuiltInColorSchemes.d.ts.map

package/types/src/theme/_BuiltInFontSchemes.d.ts

@@ -0,0 +1,3 @@
+declare const _BuiltInFontSchemes: string[][];
+export default _BuiltInFontSchemes;
+//# sourceMappingURL=_BuiltInFontSchemes.d.ts.map

package/types/src/theme/_BuiltInThemeDefs.d.ts

@@ -0,0 +1,3 @@
+declare const _BuiltInThemeDefs: string[][];
+export default _BuiltInThemeDefs;
+//# sourceMappingURL=_BuiltInThemeDefs.d.ts.map

package/types/src/theme/_ThemeMessages.d.ts

@@ -0,0 +1,3 @@
+export declare const ERROR_READONLY = "Themes is readonly. To make modifications create a new DocsThemes instance.";
+export declare const ERROR_THEME_IS_NULL = "Theme cannot be null.";
+//# sourceMappingURL=_ThemeMessages.d.ts.map

package/types/src/theme/_ThemeUtils.d.ts

@@ -0,0 +1,3 @@
+import { IColor } from '../color';
+export declare function buildPalette(colors: IColor.DefinitionWithLabel[], schemeLookup: IColor.SchemeLookup, map: Map<string, IColor>, mapRGB: Map<string, IColor>): IColor.DefinitionWithLabel[][];
+//# sourceMappingURL=_ThemeUtils.d.ts.map

package/types/src/theme/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ITheme';
+export * from './IThemeCollection';
+export * from './ThemeCollection';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,594 @@
+import { ITypes } from '../type';
+import { IListener } from '../listener';
+/**
+ * Objects that implement this interface have ACID properties.
+ */
+export interface ITransaction {
+    /**
+     * Begin a transaction with self contained, non-eventing updates.
+     *
+     * @remarks
+     * `description` is useful for debugging and logging.
+     *
+     * Transactions are treated as a stack so with fifo remove. When the final commit is applied
+     * to global only the final transaction will be maintained.
+     *
+     * @param options The description of the transaction or options.
+     * @param onClose A callback for when the transaction is closed (due to either a commit or rollback).
+     */
+    beginTransaction(options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): ITransaction;
+    /**
+     * Commit the transaction and all children transactions to the parent transaction.
+     *
+     * @param options A final description or options to apply on commit.
+     */
+    commit<View = any, P = any>(options?: ITransaction.StoreOperationOptions<View, P>): ITransaction;
+    /**
+     * Discard all changes and children transaction changes.
+     */
+    rollback(): ITransaction;
+    /**
+     * If root transaction will return self.
+     */
+    getParent(): ITransaction;
+    /**
+     * A unique id for this transaction. This will be the same id for all sub transactions.
+     */
+    getId(): string;
+    /**
+     * Describes the current transaction.
+     */
+    getDescription(): string;
+    /**
+     * 0-Based depth of the current transaction. If 0 then it's globally available.
+     */
+    getDepth(): number;
+    /**
+     * Returns the state associated to a record for the current transaction or globally if there are no open transactions.
+     *
+     * @param stateId The store-issued record id ({@link ITransaction.IStore.create}).
+     */
+    getState<STATE = any>(stateId: string): Readonly<STATE>;
+    /**
+     * Update the state for a record.
+     *
+     * @param stateId The store-issued record id ({@link ITransaction.IStore.create}).
+     * @param state A partial to merge, or a function of the previous state. Returning the
+     * previous state unchanged records nothing (a batch of such calls elides).
+     */
+    updateState<STATE = any>(stateId: string, state: (Readonly<Partial<STATE>> | ((prev: Readonly<STATE>) => Readonly<STATE>))): STATE;
+    /**
+     * All states in the current transaction, keyed by stateId.
+     */
+    getStates(): Map<string, any>;
+    /**
+     * Returns the view associated with this transaction.
+     */
+    getView(): Record<string, any> | null;
+}
+/**
+ * {@inheritDoc ITransaction}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ITransaction}
+ */
+export declare namespace ITransaction {
+    /**
+     * The identity fields the store stamps onto every committed state record.
+     *
+     * @remarks
+     * Records are store-owned clones — a model's proposed state is cloned on `updateState`, and
+     * the clone is stamped at commit. The fields are non-enumerable so they read normally
+     * (`state.version`) but never leak into model spreads, `JSON.stringify` or deep-equality;
+     * they are typed optional because a record only carries them after its first commit.
+     */
+    interface StateRecord {
+        /** The stable state id ({@link IStore.create}). */
+        readonly id?: string;
+        /** The commit sequence id of the commit that wrote this record ({@link IStore.getVersionId}). */
+        readonly version?: number;
+    }
+    /**
+     * Objects that implement this interface allow for batch operations.
+     */
+    interface ITransactional {
+        /**
+         * A unique identifier for the record. This will never change.
+         *
+         * @remarks
+         * This enables the record to be identified across transactions and users in a collaborative environment.
+         * The id is store-issued ({@link IStore.create}); the store keys all state by it.
+         */
+        getId(): string;
+        /**
+         * Every committed update gives the record a new, strictly increasing version id.
+         *
+         * @remarks
+         * Used with {@link getId} to uniquely identify a version of the record.
+         *
+         * The id is an *identity*, not a per-record count: ids are drawn from a single store-wide
+         * sequence bumped once per commit, so all records written in the same commit share an id
+         * and a given record's ids increase but are not sequential.
+         *
+         * Records are immutable so a restore/revert doesn't change them — it repoints, and the
+         * version id reported is the one for the snapshot the store is currently at. Version ids
+         * are never reused: a write after an undo receives an id higher than any previously
+         * issued, so a stale reader can always detect the change.
+         */
+        getVersionId(): number;
+        /**
+         * Provides a mechanism to perform a set of operations in a batch.
+         *
+         * @param callback A callback that performs multiple operations all within the same transaction.
+         * @param options Description of the operation or additional options. Used for tracking undo/redo and history. Default Value `User Operation`.
+         *
+         * @remarks
+         * Writes are tracked automatically: a batch that performs no state updates (a read-only
+         * batch) is elided — the commit id is unchanged, no events fire, and nothing is added to
+         * the undo stack or commit log.
+         */
+        doBatch<R = any>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
+        /**
+         * Batches all 'transactional' changes until they have all be committed or rolled back.
+         *
+         * @remarks
+         * Any changes that are made to this object will be reflected in the local record but
+         * not committed to the transactional store until the batch is popped.
+         *
+         * Useful for operations that are longer running but generally not recommended
+         * as it keeps a transaction open. {@link doBatch} is the preferred option.
+         *
+         * @param options Description of the operation or additional options. Used for tracking undo/redo and history. Default Value `User Operation`.
+         */
+        beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
+        /**
+         * Close the record and cleans resources. Can't be undone.
+         */
+        close(): void;
+        /**
+         * Returns `true` if no more operations are allowed.
+         */
+        isClosed(): boolean;
+    }
+    interface ICommit {
+        /**
+         * Returns the unique identifier for the commit.
+         */
+        getId(): string;
+        /**
+         * A human readable description of the commit.
+         */
+        getDescription(): string;
+        /**
+         * Additional meta information set during open and close.
+         */
+        getMeta(): Readonly<Record<string, string>>;
+        /**
+         * The author of the commit, or `null` when unattributed.
+         */
+        getAuthor(): ITransaction.Author | null;
+        /**
+         * The time the commit was created.
+         */
+        getTimestamp(): number;
+        /**
+         * Returns the operation that was used to create the commit.
+         *
+         * @remarks
+         * It is possible that a batch operation was used to create the commit.
+         */
+        getOperation(): Readonly<Operation>;
+    }
+    /**
+     * When the first transaction this will contain the name of parameters of the input
+     */
+    interface Operation<PARAMS = any> {
+        /**
+         * The name of the operations.
+         *
+         * @remarks
+         * This name should be unique per model type. This is used for audit and collaboration.
+         */
+        name: string;
+        /**
+         * The parameters for the operation.
+         */
+        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.
+         *
+         * @defaultValue false
+         */
+        force?: boolean;
+    }
+    interface StoreConstructorOptions {
+        /**
+         * The creator of the transactions.
+         */
+        author?: string;
+        /**
+         * If true will try to default to synchronous eventing.
+         *
+         * @defaultValue 'setDefaultSync'
+         */
+        sync?: boolean;
+        /**
+         * If true will not track changes for restoring.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * Useful for creating temporary models that don't need to be tracked.
+         */
+        transient?: boolean;
+        /**
+         * The maximum number of commits retained for restore/revert and the log.
+         *
+         * @defaultValue 1000
+         *
+         * @remarks
+         * When exceeded, the oldest commits are dropped: {@link IStore.getLog} simply ends there
+         * and a restore/revert to a dropped commit fails with an invalid id. Snapshots share
+         * unchanged records structurally, so the cost of history is per-commit bookkeeping, not
+         * full copies — but unbounded agent-driven histories still add up.
+         */
+        maxCommits?: number;
+    }
+    interface IStore {
+        /**
+         * Add a listener to listen for changes.
+         */
+        addListener(listener: ITransaction.IListeners): IListener.Remove;
+        /**
+         * Add a listener for state changes to a specific record.
+         *
+         * @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;
+        /**
+         * Returns the last commits of commits.
+         * @param commitId The commit id to start from.
+         * @param max - The maximum number of commits to return. *default* `100`.
+         */
+        getLog(commitId: string, max?: number): ITransaction.ICommit[];
+        /**
+         * Returns the total number of commits.
+         */
+        getCommitCount(): number;
+        /**
+         * Returns the current commit.
+         *
+         * @param includePending If `false`, always the last *completed* commit — a stable log id even
+         * while a transaction is open. *default* `true`.
+         *
+         * @remarks
+         * Returns either the last completed commit or the current pending.
+         */
+        getCurrentCommit(includePending?: boolean): ITransaction.ICommit;
+        /**
+         * Returns the newest *committed* point of the history — the tip.
+         *
+         * @remarks
+         * Unlike {@link getCurrentCommit} the tip does not move on {@link restore}/{@link revert};
+         * the segment from the current commit forward to the tip is the redo history. Together with
+         * {@link getLog} this is the pull primitive for "what happened since commit X": walk the log
+         * from the tip back to the last id you saw. Listener events are dispatched on a deferred
+         * tick, so a consumer whose next action depends on being current should pull, not wait.
+         */
+        getTipCommit(): ITransaction.ICommit;
+        /**
+         * Returns `true` if there is an open transaction.
+         */
+        isOpenTransaction(): boolean;
+        /**
+         * Returns the current view associated with the entire commit.
+         *
+         * @remarks
+         * Will return `null` if there is no open transaction.
+         */
+        getPendingView(): Record<string, any> | 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 version id of a record at the current commit.
+         *
+         * @param stateId The store-issued record id ({@link create}).
+         * @returns The version id, or `0` if the record has never been committed.
+         *
+         * @remarks
+         * Ids come from a single store-wide sequence bumped once per commit: a record's id
+         * increases on every committed write (but is not sequential per record), and records
+         * written in the same commit share an id. Because records are immutable, a
+         * restore/revert repoints the store and this reports the id of the snapshot the store
+         * is currently at; ids themselves are never reused. Reads during an open transaction
+         * report the last *committed* id — pending (uncommitted) writes have no id yet.
+         */
+        getVersionId(stateId: string): number;
+        /**
+         * Begin a transaction using the current commit.
+         *
+         * @param options
+         * @param onClose
+         */
+        beginCommit(options?: ITransaction.StoreOperationOptions | string, onClose?: ITransaction.CloseCallback): ITransaction;
+        /**
+         * Used by `ITransactional` objects. Both to expose `doBatch` and to implement
+         * their own internal transactions.
+         */
+        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: ITransaction.StoreOperationOptions, onClose?: ITransaction.CloseCallback): Promise<R> | R;
+        /**
+         * Create a record, minting its stable state id. The opposite of {@link remove}.
+         *
+         * @param initial The initial state to seed, if any.
+         * @returns The store-issued state id — the model's identity ({@link ITransactional.getId})
+         * and the key for every other store operation.
+         *
+         * @remarks
+         * When `initial` is provided, creation is a *write*: it joins an open transaction (or
+         * commits one), so undo/restore naturally un-creates — the prior snapshot simply has no
+         * record. With no `initial` this only mints the id; the record exists once first written.
+         */
+        create<STATE = any>(initial?: Readonly<STATE>): string;
+        /**
+         * Physically remove a record from the store. **Not undoable.** The opposite of {@link create}.
+         *
+         * @param stateId The store-issued record id ({@link create}).
+         * @returns A flag indicating if anything was removed.
+         *
+         * @remarks
+         * Fires {@link IStateListener.onClose} and detaches the record's state listeners, then
+         * purges the record from every snapshot (history included) and any open transactions.
+         * For the logical, undoable flavor use the model's `delete` (a state flag).
+         */
+        remove(stateId: string): boolean;
+        /**
+         * Set the state to a previous history point.
+         *
+         * @param commitId
+         * @param options
+         *
+         * @remarks
+         * Can be any previous restore point available in before the current commit
+         * or after the current commit.
+         */
+        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.
+         *
+         * @param commitId
+         * @param options
+         *
+         * @remarks
+         * Can be any previous restore point available in before the current commit
+         * or after the current commit.
+         */
+        revert(commitId: string, options?: ITransaction.RestoreOptions): ITransaction.ICommit;
+    }
+    /**
+     * Listener interface for TransactionStore
+     */
+    interface IListeners {
+        /**
+         * Called when a commit is started.
+         *
+         * @param commit The commit handle.
+         *
+         * @remarks
+         * This allows for additional transactional changes to be made such as transaction listeners.
+         */
+        onCommitStart?(commit: ITransaction.ICommit): void;
+        /**
+         * Called after a successful commit.
+         *
+         * @param commit
+         *
+         * @remarks
+         * * A rollback will not trigger this event.
+         * * A restore/revert will trigger this event.
+         */
+        onCommitEnd?(commit: ITransaction.ICommit): void;
+        /**
+         * Called if the commit changes for any reason.
+         *
+         * @param commit
+         */
+        onCommitChange?(commit: ITransaction.ICommit): void;
+    }
+    /**
+     * A source of **durable-commit** notifications: something that announces when a store's committed
+     * state has been externally persisted (e.g. a successful {@link IWorkbookIO.write}).
+     *
+     * @remarks
+     * This is the seam a {@link TransactionSaveStateManager} subscribes to, so a consumer can wire
+     * dirty-tracking to persistence by simply passing the source — no per-consumer event plumbing.
+     * Implemented by the IO layer (which depends on `transaction`, never the reverse).
+     *
+     * Distinct from the in-memory commit lifecycle on {@link ITransaction.IListeners}: that fires for
+     * *every* transaction commit, whereas {@link ICommitSource.IListeners.onCommit} fires only when a
+     * commit has been persisted.
+     */
+    interface ICommitSource {
+        /**
+         * Subscribe to durable-commit notifications.
+         *
+         * @param listener The callbacks object.
+         * @returns A function that removes the listener.
+         */
+        addCommitListener(listener: ITransaction.ICommitSource.IListeners): IListener.Remove;
+    }
+    namespace ICommitSource {
+        /**
+         * Describes a commit that has been persisted.
+         */
+        interface CommitEvent {
+            /**
+             * The store whose state was persisted.
+             *
+             * @remarks
+             * A single source (e.g. the shared `WorkbookIO`) services many roots, so a per-root consumer
+             * matches this against its own store to react only to its own commits.
+             */
+            store: ITransaction.IStore;
+            /**
+             * The commit id of the persisted state — captured when the bytes were *encoded*, so a save
+             * marks exactly that state clean even if the user edits during an async write.
+             */
+            commitId: string | null;
+        }
+        /**
+         * Listener interface for {@link ITransaction.ICommitSource}.
+         */
+        interface IListeners {
+            /**
+             * Called after a commit has been persisted.
+             *
+             * @param event Details of the persisted commit.
+             */
+            onCommit?(event: ITransaction.ICommitSource.CommitEvent): void;
+        }
+    }
+    interface IStateListener<STATE = any, VIEW = 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.
+         */
+        onBeforeCommitStart?(state: STATE, view: VIEW, commit: ITransaction.ICommit): void;
+        /**
+         * Called during a transaction.
+         *
+         * @remarks
+         * This is when changes should be applied. The view will only be provided if restore is used.
+         */
+        onBeforeCommitEnd?(state: STATE, view: VIEW, commit: ITransaction.ICommit): 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;
+        /**
+         * 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;
+        /**
+         * Called when a model is removed from the transaction.
+         */
+        onClose?(commit: ITransaction.ICommit): void;
+    }
+    /**
+     * Called when a transaction is closed.
+     */
+    interface CloseCallback {
+        (transaction: ITransaction, isRollback: boolean, options: ITransaction.OperationOptions): void;
+    }
+    /**
+     * Who authored a commit.
+     *
+     * @remarks
+     * `user` — an interactive edit in a UI. `agent` — a change driven through the agent tool
+     * surface (MCP `run`). `macro` — a script the user ran themselves. The author is the
+     * staleness signal for an agent reading a commit log: commits it did not write mean the
+     * session moved under it.
+     */
+    type Author = 'user' | 'agent' | 'macro';
+    /**
+     * Options for Operations that change the state.
+     */
+    interface OperationOptions {
+        /**
+         * A human description.
+         *
+         * @defaultValue 'determined by the set operation and locale'
+         */
+        description?: string;
+        /**
+         * Who authored this change. Recorded on the commit ({@link ICommit.getAuthor}).
+         *
+         * @defaultValue the store's author, else `null` (unattributed)
+         */
+        author?: Author;
+        /**
+         * If `true` or set then this will select the affect item after the transaction is complete.
+         *
+         * @remarks
+         * If this is set to `true` then any restore will also select.
+         */
+        autoSelect?: boolean | ITypes.SelectOptions;
+        /**
+         * Declares the operation read-only: any state update within it throws.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * Writes are tracked automatically — a batch that performs no updates never creates a
+         * commit (no new commit id, no events, no undo entry) whether or not this is set. The
+         * flag is purely an assertion for callers that want the guarantee enforced.
+         * Nested transactions inherit it; they cannot opt back out.
+         */
+        readOnly?: boolean;
+        /**
+         * Optimistic concurrency guard. If set, the operation only begins if the store's
+         * current commit id matches; otherwise a {@link TransactionConflictError} is thrown.
+         *
+         * @remarks
+         * The check happens atomically as the root transaction begins — there is no window
+         * between check and commit. If any transaction is already open the check fails with
+         * reason `open` (the head could move beneath the operation).
+         */
+        expectedCommitId?: string;
+    }
+    /**
+     * Options for operations with the store.
+     */
+    interface StoreOperationOptions<VIEW = any, PARAMS = any> extends OperationOptions {
+        /**
+         * 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
+         * committed or rolled back, this restriction is automatically lifted.
+         *
+         * @defaultValue false
+         */
+        preventFurtherTransactions?: boolean;
+        /**
+         * If set to `true`, The commit will not create a new snapshot but instead merge with the existing.
+         *
+         * @defaultValue false
+         *
+         * @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.
+         */
+        forceAmend?: boolean;
+        /**
+         * Stored with the commit.
+         */
+        meta?: Record<string, string>;
+        /**
+         * Used to record audit points.
+         */
+        operation?: ITransaction.Operation<PARAMS>;
+        viewAfter?: VIEW | ((prev: VIEW) => VIEW);
+        viewBefore?: VIEW | ((prev: VIEW) => VIEW);
+    }
+}
+//# sourceMappingURL=ITransaction.d.ts.map