atom.io 0.14.6 → 0.14.8

package/react-devtools/dist/index.d.cts

@@ -1,342 +0,0 @@
-import * as atom_io from 'atom.io';
-import { FamilyMetadata, ƒn, TransactionUpdate, MutableAtomToken, AtomToken, StateToken, TimelineUpdate, StateUpdate, AtomFamily, ReadonlySelectorFamily, SelectorFamily, ReadonlySelectorToken, SelectorToken, TransactionToken, TimelineToken, AtomIOLogger, Logger } from 'atom.io';
-import { Json } from 'atom.io/json';
-
-type ClassSignature = abstract new (...args: any) => any;
-
-type RefinementStrategy = ClassSignature | Refinement$1<unknown, any>;
-type Supported<Refine extends RefinementStrategy> = Refine extends Refinement$1<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
-type RefinementSupport = Record<string, RefinementStrategy>;
-declare class Refinery<SupportedTypes extends RefinementSupport> {
-    supported: SupportedTypes;
-    constructor(supported: SupportedTypes);
-    refine(input: unknown): {
-        [K in keyof SupportedTypes]: {
-            type: K;
-            data: Supported<SupportedTypes[K]>;
-        };
-    }[keyof SupportedTypes] | null;
-}
-
-interface Refinement$1<A, B extends A> {
-    (a: A): a is B;
-}
-
-type PlainObject = Record<keyof any, unknown>;
-
-declare class Subject<T> {
-    Subscriber: (value: T) => void;
-    subscribers: Map<string, this[`Subscriber`]>;
-    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
-    private unsubscribe;
-    next(value: T): void;
-}
-declare class StatefulSubject<T> extends Subject<T> {
-    state: T;
-    constructor(initialState: T);
-    next(value: T): void;
-}
-
-type Selector<T> = {
-    key: string;
-    type: `selector`;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => T;
-    set: (newValue: T | ((oldValue: T) => T)) => void;
-};
-type ReadonlySelector<T> = {
-    key: string;
-    type: `readonly_selector`;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    get: () => T;
-};
-
-type Transaction<ƒ extends ƒn> = {
-    key: string;
-    type: `transaction`;
-    install: (store: Store) => void;
-    subject: Subject<TransactionUpdate<ƒ>>;
-    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-};
-
-type TransactionMeta<ƒ extends ƒn> = {
-    phase: `applying` | `building`;
-    time: number;
-    update: TransactionUpdate<ƒ>;
-};
-
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-
-type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
-type Cardinality = `1:1` | `1:n` | `n:n`;
-
-interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
-    readonly relations: [string, string[]][];
-    readonly contents: [string, Content][];
-}
-interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
-    readonly between: [a: ASide, b: BSide];
-    readonly cardinality: Cardinality;
-}
-type BaseExternalStoreConfiguration = {
-    addRelation: (a: string, b: string) => void;
-    deleteRelation: (a: string, b: string) => void;
-    replaceRelationsSafely: (a: string, bs: string[]) => void;
-    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
-    getRelatedKeys: (key: string) => Set<string> | undefined;
-    has: (a: string, b?: string) => boolean;
-};
-type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
-    getContent: (contentKey: string) => Content | undefined;
-    setContent: (contentKey: string, content: Content) => void;
-    deleteContent: (contentKey: string) => void;
-};
-type Empty<Obj extends object> = {
-    [Key in keyof Obj]?: undefined;
-};
-type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
-type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
-    externalStore?: ExternalStoreConfiguration<Content>;
-    isContent?: Refinement<unknown, Content>;
-    makeContentKey?: (a: string, b: string) => string;
-};
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
-    readonly a: ASide;
-    readonly b: BSide;
-    readonly cardinality: Cardinality;
-    readonly relations: Map<string, Set<string>>;
-    readonly contents: Map<string, Content>;
-    isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: string, b: string) => string;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    protected addRelation(a: string, b: string): void;
-    protected deleteRelation(a: string, b: string): void;
-    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
-    protected replaceRelationsSafely(a: string, bs: string[]): void;
-    protected getContentInternal(contentKey: string): Content | undefined;
-    protected setContent(contentKey: string, content: Content): void;
-    protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
-    toJSON(): JunctionJSON<ASide, BSide, Content>;
-    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
-    set(relation: {
-        [Key in ASide | BSide]: string;
-    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
-    delete(a: string, b?: string): this;
-    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
-    getRelatedKey(key: string): string | undefined;
-    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
-        reckless: boolean;
-    }): this;
-    getContent(a: string, b: string): Content | undefined;
-    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
-    has(a: string, b?: string): boolean;
-}
-
-interface Lineage {
-    parent: typeof this | null;
-    child: typeof this | null;
-}
-
-interface Transceiver<Signal extends Json.Serializable> {
-    do: (update: Signal) => void;
-    undo: (update: Signal) => void;
-    subscribe: (key: string, fn: (update: Signal) => void) => () => void;
-    cacheUpdateNumber: number;
-    getUpdateNumber: (update: Signal) => number;
-}
-
-/**
- * @internal Give the tracker a transceiver state and a store, and it will
- * subscribe to the transceiver's inner value. When the inner value changes,
- * the tracker will update its own state to reflect the change.
- */
-declare class Tracker<Mutable extends Transceiver<any>> {
-    private Update;
-    private initializeState;
-    private unsubscribeFromInnerValue;
-    private observeCore;
-    private updateCore;
-    mutableState: MutableAtomToken<Mutable, Json.Serializable>;
-    latestUpdateState: AtomToken<typeof this.Update | null>;
-    constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
-}
-
-interface MutableAtom<T> extends Atom<T> {
-    mutable: true;
-}
-
-type OperationProgress = {
-    open: false;
-} | {
-    open: true;
-    done: Set<string>;
-    prev: Map<string, any>;
-    time: number;
-    token: StateToken<any>;
-};
-
-type TimelineAtomUpdate = StateUpdate<unknown> & {
-    key: string;
-    type: `atom_update`;
-    timestamp: number;
-    family?: FamilyMetadata;
-};
-type TimelineSelectorUpdate = {
-    key: string;
-    type: `selector_update`;
-    timestamp: number;
-    atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[];
-};
-type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
-    key: string;
-    type: `transaction_update`;
-    timestamp: number;
-};
-type Timeline = {
-    type: `timeline`;
-    key: string;
-    at: number;
-    shouldCapture?: (update: TimelineUpdate, timeline: Timeline) => boolean;
-    timeTraveling: `into_future` | `into_past` | null;
-    history: TimelineUpdate[];
-    selectorTime: number | null;
-    transactionKey: string | null;
-    install: (store: Store) => void;
-    subject: Subject<TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate | `redo` | `undo`>;
-};
-
-declare class Store implements Lineage {
-    parent: Store | null;
-    child: Store | null;
-    valueMap: Map<string, any>;
-    atoms: Map<string, Atom<any> | MutableAtom<any>>;
-    selectors: Map<string, Selector<any>>;
-    readonlySelectors: Map<string, ReadonlySelector<any>>;
-    trackers: Map<string, Tracker<Transceiver<any>>>;
-    families: Map<string, AtomFamily<any, any> | ReadonlySelectorFamily<any, any> | SelectorFamily<any, any>>;
-    timelines: Map<string, Timeline>;
-    transactions: Map<string, Transaction<ƒn>>;
-    atomsThatAreDefault: Set<string>;
-    timelineAtoms: Junction<"timelineKey", "atomKey", null>;
-    selectorAtoms: Junction<"selectorKey", "atomKey", null>;
-    selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
-        source: string;
-    }>;
-    subject: {
-        atomCreation: Subject<AtomToken<unknown>>;
-        selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
-        transactionCreation: Subject<TransactionToken<ƒn>>;
-        timelineCreation: Subject<TimelineToken>;
-        transactionApplying: StatefulSubject<TransactionMeta<ƒn> | null>;
-        operationStatus: Subject<OperationProgress>;
-    };
-    operation: OperationProgress;
-    transactionMeta: TransactionMeta<ƒn> | null;
-    config: {
-        name: string;
-    };
-    loggers: AtomIOLogger[];
-    logger: Logger;
-    constructor(name: string, store?: Store | null);
-}
-
-type Atom<T> = {
-    key: string;
-    type: `atom`;
-    mutable?: boolean;
-    family?: FamilyMetadata;
-    install: (store: Store) => void;
-    subject: Subject<{
-        newValue: T;
-        oldValue: T;
-    }>;
-    default: T | (() => T);
-    cleanup?: () => void;
-};
-
-type AtomTokenIndex = StateTokenIndex<AtomToken<unknown>>;
-
-type FamilyNode<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = {
-    key: string;
-    familyMembers: Record<string, Token>;
-};
-type StateTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | SelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
-
-type SelectorTokenIndex = StateTokenIndex<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
-
-type Delta = {
-    summary: string;
-    added?: [path: string, addedStringifiedValue: string][];
-    removed?: [path: string, removedStringifiedValue: string][];
-    changed?: [path: string, delta: Delta][];
-};
-type Diff<T> = (a: T, b: T) => Delta;
-type DiffTree<T> = (a: T, b: T, recurse: Differ<any, any>[`diff`]) => Delta;
-declare class Differ<Leaf extends Record<string, any>, Tree extends Record<string, any>> {
-    leafRefinery: Refinery<Leaf>;
-    treeRefinery: Refinery<Tree>;
-    leafDiffers: {
-        [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>;
-    };
-    treeDiffers: {
-        [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>;
-    };
-    constructor(leafRefinery: Refinery<Leaf>, treeRefinery: Refinery<Tree>, diffFunctions: {
-        [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>;
-    } & {
-        [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>;
-    });
-    diff(a: unknown, b: unknown): Delta;
-}
-
-declare const AtomIODevtools: () => JSX.Element;
-
-declare const atomIndex: atom_io.ReadonlySelectorToken<AtomTokenIndex>;
-declare const selectorIndex: atom_io.ReadonlySelectorToken<SelectorTokenIndex>;
-declare const transactionIndex: atom_io.ReadonlySelectorToken<atom_io.TransactionToken<atom_io.ƒn>[]>;
-declare const findTransactionLogState: atom_io.ReadonlySelectorFamily<atom_io.TransactionUpdate<atom_io.ƒn>[]>;
-declare const timelineIndex: atom_io.ReadonlySelectorToken<atom_io.TimelineToken[]>;
-declare const findTimelineState: atom_io.ReadonlySelectorFamily<Timeline>;
-declare const devtoolsAreOpenState: atom_io.AtomToken<boolean>;
-type DevtoolsView = `atoms` | `selectors` | `timelines` | `transactions`;
-declare const devtoolsViewSelectionState: atom_io.AtomToken<DevtoolsView>;
-declare const devtoolsViewOptionsState: atom_io.AtomToken<DevtoolsView[]>;
-declare const findViewIsOpenState: atom_io.AtomFamily<boolean, string>;
-declare const primitiveRefinery: Refinery<{
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}>;
-declare const jsonTreeRefinery: Refinery<{
-    object: (input: unknown) => input is PlainObject;
-    array: (input: unknown) => input is unknown[];
-}>;
-declare const prettyJson: Differ<{
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}, {
-    object: (input: unknown) => input is PlainObject;
-    array: (input: unknown) => input is unknown[];
-}>;
-
-export { AtomIODevtools, atomIndex, devtoolsAreOpenState, devtoolsViewOptionsState, devtoolsViewSelectionState, findTimelineState, findTransactionLogState, findViewIsOpenState, jsonTreeRefinery, prettyJson, primitiveRefinery, selectorIndex, timelineIndex, transactionIndex };

package/realtime-client/dist/index.d.cts

@@ -1,22 +0,0 @@
-import * as AtomIO from 'atom.io';
-import * as Internal from 'atom.io/internal';
-import { Store, Transceiver } from 'atom.io/internal';
-import { Json } from 'atom.io/json';
-import { Socket } from 'socket.io-client';
-
-declare const myIdState__INTERNAL: AtomIO.AtomToken<string | null>;
-declare const myIdState: AtomIO.ReadonlySelectorToken<string | null>;
-
-declare function pullState<J extends Json.Serializable>(token: AtomIO.StateToken<J>, socket: Socket, store: Store): () => void;
-
-declare function pullFamilyMember<J extends Json.Serializable>(token: AtomIO.AtomToken<J>, socket: Socket, store: Store): () => void;
-
-declare function pullMutableState<T extends Transceiver<Json.Serializable>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>, socket: Socket, store: Store): () => void;
-
-declare function pullMutableFamilyMember<T extends Transceiver<Json.Serializable>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>, socket: Socket, store: Store): () => void;
-
-declare function pushState<J extends Json.Serializable>(token: AtomIO.StateToken<J>, socket: Socket, subscriptionKey: string, store: Internal.Store): () => void;
-
-declare function synchronizeTransactionResults(token: AtomIO.TransactionToken<any>, socket: Socket, store: Internal.Store): () => void;
-
-export { myIdState, myIdState__INTERNAL, pullFamilyMember, pullMutableFamilyMember, pullMutableState, pullState, pushState, synchronizeTransactionResults };

package/realtime-react/dist/index.d.cts

@@ -1,27 +0,0 @@
-import * as React from 'react';
-import { Socket } from 'socket.io-client';
-import * as AtomIO from 'atom.io';
-import { Json } from 'atom.io/json';
-import { Transceiver } from 'atom.io/internal';
-
-declare const RealtimeContext: React.Context<{
-    socket: Socket;
-}>;
-declare const RealtimeProvider: React.FC<{
-    children: React.ReactNode;
-    socket: Socket;
-}>;
-
-declare function usePull<J extends Json.Serializable>(token: AtomIO.StateToken<J>): void;
-
-declare function usePullFamilyMember<J extends Json.Serializable>(token: AtomIO.AtomToken<J>): void;
-
-declare function usePullMutable<T extends Transceiver<Json.Serializable>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>): void;
-
-declare function usePullMutableFamilyMember<T extends Transceiver<Json.Serializable>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>): void;
-
-declare function usePush<J extends Json.Serializable>(token: AtomIO.StateToken<J>): void;
-
-declare function useServerAction<ƒ extends AtomIO.ƒn>(token: AtomIO.TransactionToken<ƒ>): (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
-
-export { RealtimeContext, RealtimeProvider, usePull, usePullFamilyMember, usePullMutable, usePullMutableFamilyMember, usePush, useServerAction };

package/realtime-server/dist/index.d.cts

@@ -1,25 +0,0 @@
-import { Transceiver, Store } from 'atom.io/internal';
-import * as SocketIO from 'socket.io';
-import * as AtomIO from 'atom.io';
-import { StateToken } from 'atom.io';
-import { Json } from 'atom.io/json';
-
-declare const useExposeSingle: ({ socket, store, }: ServerConfig) => <J extends Json.Serializable>(token: AtomIO.StateToken<J>) => () => void;
-
-declare const useExposeFamily: ({ socket, store, }: ServerConfig) => <J extends Json.Serializable>(family: AtomIO.AtomFamily<J, Json.Serializable> | AtomIO.SelectorFamily<J, Json.Serializable>, index: AtomIO.StateToken<Set<string>>) => () => void;
-
-declare const useExposeMutable: ({ socket, store, }: ServerConfig) => <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(token: AtomIO.MutableAtomToken<Core, SerializableCore>) => () => void;
-
-declare const useExposeMutableFamily: ({ socket, store, }: ServerConfig) => <Family extends AtomIO.MutableAtomFamily<Transceiver<Json.Serializable>, Json.Serializable, Json.Serializable>>(family: Family, index: AtomIO.StateToken<Set<string>>) => () => void;
-
-declare const useReceiveTransaction: ({ socket, store }: ServerConfig) => <ƒ extends AtomIO.ƒn>(tx: AtomIO.TransactionToken<ƒ>) => () => void;
-declare function useSyncTransaction({ socket, store, }: ServerConfig): <ƒ extends AtomIO.ƒn>(tx: AtomIO.TransactionToken<ƒ>) => () => void;
-
-declare const useReceiveState: ({ socket, store }: ServerConfig) => <J extends Json.Serializable>(token: StateToken<J>) => () => void;
-
-type ServerConfig = {
-    socket: SocketIO.Socket;
-    store?: Store;
-};
-
-export { type ServerConfig, useExposeFamily, useExposeMutable, useExposeMutableFamily, useExposeSingle, useReceiveState, useReceiveTransaction, useSyncTransaction };

package/realtime-testing/dist/index.d.cts

@@ -1,49 +0,0 @@
-import { RenderResult } from '@testing-library/react';
-import * as AtomIO from 'atom.io';
-import * as React from 'react';
-import * as SocketIO from 'socket.io';
-
-type TestSetupOptions = {
-    server: (tools: {
-        socket: SocketIO.Socket;
-        silo: AtomIO.Silo;
-    }) => void;
-};
-type TestSetupOptions__SingleClient = TestSetupOptions & {
-    client: React.FC;
-};
-type TestSetupOptions__MultiClient<ClientNames extends string> = TestSetupOptions & {
-    clients: {
-        [K in ClientNames]: React.FC;
-    };
-};
-type RealtimeTestTools = {
-    name: string;
-    silo: AtomIO.Silo;
-    dispose: () => void;
-};
-type RealtimeTestClient = RealtimeTestTools & {
-    renderResult: RenderResult;
-    prettyPrint: () => void;
-    reconnect: () => void;
-    disconnect: () => void;
-};
-type RealtimeTestServer = RealtimeTestTools & {
-    port: number;
-};
-type RealtimeTestAPI = {
-    server: RealtimeTestServer;
-    teardown: () => void;
-};
-type RealtimeTestAPI__SingleClient = RealtimeTestAPI & {
-    client: RealtimeTestClient;
-};
-type RealtimeTestAPI__MultiClient<ClientNames extends string> = RealtimeTestAPI & {
-    clients: Record<ClientNames, RealtimeTestClient>;
-};
-declare const setupRealtimeTestServer: (options: TestSetupOptions) => RealtimeTestServer;
-declare const setupRealtimeTestClient: (options: TestSetupOptions__SingleClient, name: string, port: number) => RealtimeTestClient;
-declare const singleClient: (options: TestSetupOptions__SingleClient) => RealtimeTestAPI__SingleClient;
-declare const multiClient: <ClientNames extends string>(options: TestSetupOptions__MultiClient<ClientNames>) => RealtimeTestAPI__MultiClient<ClientNames>;
-
-export { type RealtimeTestAPI, type RealtimeTestAPI__MultiClient, type RealtimeTestAPI__SingleClient, type RealtimeTestClient, type RealtimeTestServer, type RealtimeTestTools, type TestSetupOptions, type TestSetupOptions__MultiClient, type TestSetupOptions__SingleClient, multiClient, setupRealtimeTestClient, setupRealtimeTestServer, singleClient };

package/transceivers/set-rtx/dist/index.d.cts

@@ -1,40 +0,0 @@
-import { Transceiver, Lineage, TransceiverMode, Subject } from 'atom.io/internal';
-import { primitive, Json } from 'atom.io/json';
-
-type SetUpdate = `add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`;
-type NumberedSetUpdate = `${number}=${SetUpdate}`;
-interface SetRTXJson<P extends primitive> extends Json.Object {
-    members: P[];
-    cache: (NumberedSetUpdate | null)[];
-    cacheLimit: number;
-    cacheIdx: number;
-    cacheUpdateNumber: number;
-}
-declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<NumberedSetUpdate>, Lineage {
-    mode: TransceiverMode;
-    readonly subject: Subject<SetUpdate>;
-    cacheLimit: number;
-    cache: (NumberedSetUpdate | null)[];
-    cacheIdx: number;
-    cacheUpdateNumber: number;
-    constructor(values?: Iterable<P>, cacheLimit?: number);
-    toJSON(): SetRTXJson<P>;
-    static fromJSON<P extends primitive>(json: SetRTXJson<P>): SetRTX<P>;
-    add(value: P): this;
-    clear(): void;
-    delete(value: P): boolean;
-    readonly parent: SetRTX<P> | null;
-    child: SetRTX<P> | null;
-    transactionUpdates: SetUpdate[] | null;
-    transaction(run: (child: SetRTX<P>) => boolean): void;
-    protected _subscribe(key: string, fn: (update: SetUpdate) => void): () => void;
-    subscribe(key: string, fn: (update: NumberedSetUpdate) => void): () => void;
-    emit(update: SetUpdate): void;
-    private doStep;
-    getUpdateNumber(update: NumberedSetUpdate): number;
-    do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null;
-    undoStep(update: SetUpdate): void;
-    undo(update: NumberedSetUpdate): number | null;
-}
-
-export { type NumberedSetUpdate, SetRTX, type SetRTXJson, type SetUpdate };