@yuzhouu/canvas-kit 0.1.13 → 0.1.14

package/_vendor/canvas-core/editor/editor.d.ts

@@ -1,584 +1,356 @@
-import { type Signal } from "../../signals/index";
-import type { TerminalBindingResolver, TerminalBindingResolverInput, ResolvedTerminalBinding } from "../bindings/terminalBinding";
+import { type Signal, type SignalGraph } from "../../signals/index";
+import { Store, type ChangeSource, type RecordsDiff, type StoreChange } from "../../store/index";
+import { BindingManager } from "../bindings/bindingManager";
 import type { BindingUtil } from "../bindings/bindingUtil";
 import { BindingUtilRegistry } from "../bindings/bindingUtilRegistry";
+import type { ResolvedTerminalBinding, TerminalBindingResolver, TerminalBindingResolverInput } from "../bindings/terminalBinding";
+import { ShapeSvgExporterRegistry, exportShapesToSvgString, type ShapeSvgExporter } from "../exports/svg";
 import { Box } from "../geometry/box";
 import { Mat } from "../geometry/mat";
-import { Vec } from "../geometry/vec";
+import type { Vec } from "../geometry/vec";
 import { EditorRuntimeRegistry } from "../plugins/editorRuntimeRegistry";
-import { type BindingId, type BindingRecord, type AssetId, type AssetRecord, type Camera, type DocumentMetadataRecord, type PageId, type PageRecord, type EditorRecord, type RecordScope, type SessionRecord, type ShapeId, type ShapeParentId, type ShapeRecord, type ShapeEditingEntryRequest, type ShapeEditingSession } from "../schema/records";
-import { type DocumentSnapshot, type SessionSnapshot } from "../schema/snapshots";
+import { type AssetId, type AssetRecord, type BindingId, type BindingRecord, type Camera, type DocumentMetadataRecord, type EditorRecord, type PageId, type PageRecord, type RecordScope, type SessionRecord, type ShapeEditingSession, type ShapeId, type ShapeParentId, type ShapeRecord } from "../schema/records";
+import type { DocumentSnapshot, SessionSnapshot } from "../schema/snapshots";
 import type { ShapeSelectionFlipAxis, ShapeUtil } from "../shapes/shapeUtil";
 import { ShapeUtilRegistry } from "../shapes/shapeUtilRegistry";
-import { ShapeSvgExporterRegistry, type ShapeSvgExporter, type SvgExportOptions, type SvgExportResult } from "../exports/svg";
-import { type ExportIntegrityRepairResult, type ExportIntegrityReport } from "../exports/integrity";
-import { type ShapeCapabilityDefinition, type ShapeCapabilityManifest } from "../shapes/capabilities";
-import { Store, type ChangeSource, type StoreChange } from "../../store/index";
-import { type CreateAssetInput, type CreateBindingInput, type CreatePageInput, type CreateShapeInput, type StartEditingShapeInput, type EditorCommands } from "./commands";
-import type { CancelEditorEvent, EditorEvent } from "./events";
-import { HistoryManager, type HistoryState } from "./historyManager";
-import { EditorOperationManager } from "./operationManager";
-import { BindingManager } from "./managers/bindingManager";
-import { CameraManager } from "./managers/cameraManager";
-import { ClipboardManager } from "./managers/clipboardManager";
-import { DocumentSnapshotManager } from "./managers/documentSnapshotManager";
-import { InputsManager } from "./managers/inputsManager";
-import { InteractionTransientManager } from "./managers/interactionTransientManager";
-import { QueryManager, type ShapeHierarchySnapshotEntry, type ShapeContainment } from "./managers/queryManager";
-import { SpatialIndexManager, type ShapeAtPointOptions, type ShapeLineSegmentHitTestOptions, type SpatialQueryOptions } from "./managers/spatialIndexManager";
-import { SnapManager } from "./managers/snapManager";
-import { SideEffectManager } from "./managers/sideEffectManager";
-import { SelectionLayoutManager } from "./managers/selectionLayoutManager";
-import { SelectionManager } from "./managers/selectionManager";
-import { SelectionOverlayManager } from "./managers/selectionOverlayManager";
-import { ShapeEditingManager } from "./managers/shapeEditingManager";
-import { ShapeGeometryManager } from "./managers/shapeGeometryManager";
-import { ShapeHierarchyManager } from "./managers/shapeHierarchyManager";
-import { ShortcutManager } from "./managers/shortcutManager";
-import { RenderWindowManager } from "./managers/renderWindowManager";
-import { ToolManager } from "./managers/toolManager";
-import type { ShapeGeometry } from "./queries/shapeTransforms";
-import { editorStoreSymbol } from "./internal";
+import { ToolManager } from "../tools/toolManager";
 import type { DuplicateSelectionInput, EditorClipboardPayload, PasteClipboardPayloadInput } from "./clipboard";
-import { InteractionHandlerRegistry } from "./interactions";
-import { SelectionHandleInteractionRegistry } from "./selectionHandleInteractions";
-import { type SelectedShapeOverlayItem } from "./selectionOverlay";
-import type { BindingPreviewState, SnapIndicatorState, SelectionBindingSegment, TerminalBindingGuideState, SelectionHandle, SelectionFrame, SelectionOverlayFrameState, SelectionOverlayFrameGeometryState, SelectionOverlayFrameStyleState, SelectionOverlayHandleAnchorsState, SelectionOverlayHandleCountsState, SelectionOverlayHandlesState, SelectionOverlayState } from "./selection";
+import type { CreatePageInput, EditorCommands, ShapePropsPatch } from "./commands/commandTypes";
+import type { CancelEditorEvent, EditorEvent, EditorEventResult } from "./events/events";
+import { InputsManager } from "./events/inputsManager";
+import { InteractionHandlerRegistry } from "./events/interactions";
+import { HistoryManager } from "./history/historyManager";
+import { EditorOperationManager } from "./history/operationManager";
+import { editorStoreSymbol } from "./internal";
+import type { ShapeGeometry } from "./queries/shapeTransforms";
+import { type ShapeAtPointOptions, type ShapeLineSegmentHitTestOptions, type SpatialQueryOptions } from "./queries/spatialIndexManager";
+import type { BindingPreviewState, SelectionFrame, SelectionHandle, SnapIndicatorState, TerminalBindingGuideState } from "./selection/selection";
+import { ShapeEditingManager } from "./shapes/shapeEditingManager";
+import { type ContainerBoundsQueryOptions, type ShapeContainment } from "./shapes/shapeContainment";
+import type { ShapeGroupState } from "./shapes/shapeGrouping";
+import type { LayerOrderDirection, LayerOrderEdge, ShapeSelectionSiblingOrderState, ShapeSiblingOrderDirection, ShapeSiblingOrderEdge, ShapeSiblingOrderState } from "./shapes/shapeOrder";
+import type { ReparentShapePlacementInput, ReparentShapePlacementResult } from "./shapes/shapeReparenting";
+import { SnapManager, type SnapDiagnostics } from "./snapping/snapManager";
+import type { EditorRenderSignals, EditorStateSignals } from "./state/editorSignals";
+import { type CameraAnimationScheduler } from "./viewport/cameraManager";
 export interface EditorOptions {
     shapeUtils?: ShapeUtil[];
     shapeSvgExporters?: ShapeSvgExporter[];
     bindingUtils?: BindingUtil[];
-    shapeCapabilities?: readonly ShapeCapabilityDefinition[];
     resolveAssetUrl?: (assetId: AssetId) => string | null;
-    documentSnapshot?: unknown;
     documentMeta?: Record<string, unknown>;
-    sessionSnapshot?: unknown;
-}
-export interface ContainerBoundsQueryOptions {
-    includeIntersecting?: boolean;
-}
-export interface RenderItem {
-    id: ShapeId;
-    shape: ShapeRecord;
-    bounds: Box;
-    isSelected: boolean;
-}
-export interface EditorPageState {
-    pages: PageRecord[];
-    currentPageId: PageId;
-    currentPage: PageRecord | null;
-    canDeleteCurrentPage: boolean;
-}
-export interface EditorToolState {
-    activeToolId: string;
-    isToolLocked: boolean;
-}
-export type ShapeSiblingOrderDirection = "backward" | "forward";
-export type ShapeSiblingOrderEdge = "back" | "front";
-export interface ShapeSiblingOrderState {
-    parentId: ShapeParentId;
-    index: number;
-    count: number;
-    canMoveBackward: boolean;
-    canMoveForward: boolean;
+    onUnhandledError?: (error: unknown) => void;
+    snapDiagnostics?: SnapDiagnostics;
+    cameraAnimationScheduler?: CameraAnimationScheduler;
 }
-export interface ShapeSelectionSiblingOrderState {
-    parentId: ShapeParentId;
-    selectedCount: number;
-    count: number;
-    canMoveBackward: boolean;
-    canMoveForward: boolean;
-}
-export type ReparentShapePlacementFailureReason = "notFound" | "locked" | "hidden" | "invalidParent" | "cycle" | "invalidBeforeId" | "unsupportedTransform";
-export type ReparentShapePlacementResult = {
-    ok: true;
-    movedIds: ShapeId[];
-} | {
-    ok: false;
-    reason: ReparentShapePlacementFailureReason;
-};
-export interface ReparentShapePlacementInput {
-    ids: readonly ShapeId[];
-    parentId: ShapeParentId;
-    beforeId?: ShapeId;
-}
-export interface ShapeGroupState {
-    parentId: ShapeParentId;
-    shapeIds: ShapeId[];
-    /** Axis-aligned bounds of the grouped roots in their common parent's local space. */
-    parentLocalBounds: Box;
-}
-export type LayerOrderDirection = "backward" | "forward";
-export type LayerOrderEdge = "back" | "front";
-export type ShapePropsPatch = Record<string, unknown>;
-export interface EditorShapeEditingState {
-    editingShapeId: ShapeId | null;
-    session: ShapeEditingSession | null;
-}
-export interface EditorShapeEditingEntryRequestState {
-    request: ShapeEditingEntryRequest | null;
-}
-export interface EditorSelectionState {
-    count: number;
-    singleShapeType: ShapeRecord["type"] | null;
-    commonShapeType: ShapeRecord["type"] | null;
-    canFlipSelection: boolean;
-    hasPointHandleSelection: boolean;
-    hasFrameSelection: boolean;
-    isMixedFrameAndPointHandleSelection: boolean;
-    canDragPointHandles: boolean;
-    hasSelectionRotation: boolean;
-    hasMixedSelectionRotation: boolean;
-    canResetSelectionRotation: boolean;
-    frameBounds: Box | null;
-    frameRotation: number;
-    frameRotationCenter: Vec | null;
-    selectionAnchorPagePoint: Vec | null;
-}
-export type EditorSelectionMetadata = Omit<EditorSelectionState, "frameBounds" | "frameRotation" | "frameRotationCenter" | "selectionAnchorPagePoint">;
-export interface EditorRenderHostDebugState {
-    culledCount: number;
-    visibleCount: number;
-    retainedCount: number;
-    retainedBaseCount: number;
-    culledRangeCount: number;
-    culledRangeSpan: number;
-    culledRangesSummary: string;
-    retainedBaseRangeCount: number;
-    retainedBaseRangeSpan: number;
-    retainedBaseRangesSummary: string;
-    retainedRangeCount: number;
-    retainedRangeSpan: number;
-    retainedRangesSummary: string;
-    retainedChangeCount: number;
-    retainedAddedCount: number;
-    retainedRemovedCount: number;
-    selectedOutsideCulledCount: number;
-}
-export interface EditorOverlayDebugState {
-    selectionFrameActive: boolean;
-    selectionHandlesActive: boolean;
-    bindingPreviewActive: boolean;
-    brushBoxActive: boolean;
-    selectionFrameChangeCount: number;
-    selectionHandlesChangeCount: number;
-    resizeHandleCount: number;
-    rotateHandleCount: number;
-    terminalHandleCount: number;
-    middleHandleCount: number;
-    customHandleCount: number;
-    boundsSummary: string;
-    rotation: number | null;
-    strokeWidth: number | null;
+export interface CenterOnShapeOptions {
+    source?: ChangeSource;
+    animation?: {
+        durationMs: number;
+    };
 }
 interface ReadonlyStore {
-    readonly recordsSignal: Signal<Map<string, EditorRecord>>;
     get(id: string): EditorRecord | undefined;
-    getActiveAtomicOperationRevision(): number | null;
-    getActiveAtomicOperationSnapshot(): EditorRecord[];
+    getRevision(): number;
+    getActiveTransactionRevision(): number | null;
+    getActiveTransactionDiff(): RecordsDiff<EditorRecord>;
     getRecordSignal(id: string): Signal<EditorRecord | undefined>;
     getAll(): EditorRecord[];
     getByScope(scope: RecordScope): EditorRecord[];
     listen(listener: (change: StoreChange<EditorRecord>) => void): () => void;
 }
 export declare class Editor {
+    readonly signals: SignalGraph;
     readonly store: ReadonlyStore;
     readonly [editorStoreSymbol]: Store<EditorRecord>;
     readonly inputs: InputsManager;
-    readonly snapshots: DocumentSnapshotManager;
-    readonly clipboard: ClipboardManager;
-    readonly shortcuts: ShortcutManager;
     readonly tools: ToolManager;
-    readonly camera: CameraManager;
-    readonly selection: SelectionManager;
-    readonly selectionLayout: SelectionLayoutManager;
+    private readonly cameraManager;
     readonly editing: ShapeEditingManager;
-    readonly geometry: ShapeGeometryManager;
-    readonly hierarchy: ShapeHierarchyManager;
     readonly shapeUtils: ShapeUtilRegistry;
     readonly shapeSvgExporters: ShapeSvgExporterRegistry;
     readonly bindingUtils: BindingUtilRegistry;
     readonly interactions: InteractionHandlerRegistry;
-    readonly selectionHandleInteractions: SelectionHandleInteractionRegistry;
     readonly runtime: EditorRuntimeRegistry;
-    readonly queries: QueryManager;
-    readonly bindings: BindingManager;
-    readonly spatialIndex: SpatialIndexManager;
+    private readonly bindingQueries;
+    private readonly shapeGeometryQueries;
+    private readonly shapeTreeIndex;
+    private readonly selectionGeometry;
+    private readonly bindingManager;
+    private readonly spatialIndex;
     readonly snaps: SnapManager;
-    readonly renderWindow: RenderWindowManager;
-    readonly selectionOverlay: SelectionOverlayManager;
-    readonly transients: InteractionTransientManager;
+    private readonly renderWindowManager;
+    private readonly shapeSignals;
+    private readonly selectionOverlay;
+    private readonly interactionManager;
+    private readonly eventRouter;
     readonly history: HistoryManager;
     readonly operations: EditorOperationManager;
-    readonly sideEffects: SideEffectManager;
     readonly commands: EditorCommands;
-    private readonly shapeCapabilityDefinitions;
-    readonly brushBoxSignal: Signal<Box | null>;
-    readonly brushBoxActiveSignal: Signal<boolean>;
-    readonly bindingPreviewSignal: Signal<BindingPreviewState | null>;
-    readonly bindingPreviewActiveSignal: Signal<boolean>;
-    readonly terminalBindingGuidesSignal: Signal<TerminalBindingGuideState[]>;
-    readonly dropTargetShapeIdSignal: Signal<ShapeId | null>;
-    readonly hoveredShapeIdSignal: Signal<ShapeId | null>;
-    readonly selectionTranslationActiveSignal: Signal<boolean>;
-    readonly snapIndicatorsSignal: Signal<SnapIndicatorState[]>;
-    readonly snapIndicatorsActiveSignal: Signal<boolean>;
-    get viewportScreenSizeSignal(): Signal<{
-        w: number;
-        h: number;
-    }>;
-    readonly shapeEditingEntryRequestSignal: Signal<ShapeEditingEntryRequest | null>;
+    readonly state: EditorStateSignals;
+    readonly render: EditorRenderSignals;
     private readonly _shapeDefaultPropsByTypeSignal;
-    readonly shapeDefaultPropsByTypeSignal: Signal<ReadonlyMap<ShapeRecord["type"], ShapePropsPatch>>;
-    private nextShapeNumber;
-    private nextPageNumber;
-    private nextBindingNumber;
-    private nextAssetNumber;
     private assetUrlResolver;
-    private get _internalStore();
-    readonly sessionSignal: import("../../signals/index").Computed<SessionRecord>;
-    /** Read the latest session draft, including writes made inside store.atomic. */
-    getSessionRecord(): SessionRecord;
-    readonly currentPageIdSignal: import("../../signals/index").Computed<`page:${string}`>;
-    readonly currentPageShapeIdsSignal: Signal<ShapeId[]>;
-    readonly currentPageShapesSignal: Signal<ShapeRecord[]>;
-    readonly currentPageShapeHierarchySignal: Signal<ShapeHierarchySnapshotEntry[]>;
-    readonly culledShapeIdsSignal: Signal<ShapeId[]>;
-    readonly renderVisibleShapeIdsSignal: Signal<ShapeId[]>;
-    readonly retainedShapeIdsSignal: Signal<ShapeId[]>;
-    readonly selectionPageBoundsSignal: Signal<Box | null>;
-    readonly selectionFrameBoundsSignal: Signal<Box | null>;
-    readonly selectionAnchorPagePointSignal: Signal<Vec | null>;
-    readonly pagesSignal: import("../../signals/index").Computed<PageRecord[]>;
-    readonly currentPageSignal: import("../../signals/index").Computed<PageRecord | null>;
-    readonly pageStateSignal: import("../../signals/index").Computed<EditorPageState>;
-    readonly toolStateSignal: import("../../signals/index").Computed<EditorToolState>;
-    readonly editingShapeIdSignal: import("../../signals/index").Computed<`shape:${string}` | null>;
-    readonly shapeEditingSessionSignal: import("../../signals/index").Computed<ShapeEditingSession | null>;
-    readonly shapeEditingStateSignal: import("../../signals/index").Computed<EditorShapeEditingState>;
-    readonly currentCameraSignal: import("../../signals/index").Computed<Camera>;
-    readonly selectedShapeIdsSignal: import("../../signals/index").Computed<`shape:${string}`[]>;
-    readonly selectionCountSignal: import("../../signals/index").Computed<number>;
-    readonly selectedShapeIdSetSignal: import("../../signals/index").Computed<Set<`shape:${string}`>>;
-    readonly selectedShapesSignal: import("../../signals/index").Computed<ShapeRecord[]>;
-    readonly selectionCanFlipSignal: import("../../signals/index").Computed<boolean>;
-    readonly selectedShapeOverlayItemsSignal: import("../../signals/index").Computed<SelectedShapeOverlayItem[]>;
-    readonly selectionStateSignal: import("../../signals/index").Computed<EditorSelectionState>;
-    readonly selectionMetadataSignal: import("../../signals/index").Computed<EditorSelectionMetadata>;
-    readonly pageTransformSignal: import("../../signals/index").Computed<Mat>;
-    readonly cameraZoomSignal: import("../../signals/index").Computed<number>;
-    readonly viewportPageBoundsSignal: import("../../signals/index").Computed<Box | null>;
-    readonly renderViewportPageBoundsSignal: import("../../signals/index").Computed<Box | null>;
-    readonly renderItemsSignal: Signal<RenderItem[]>;
-    readonly renderHostDebugStateSignal: Signal<EditorRenderHostDebugState>;
-    readonly historyStateSignal: Signal<HistoryState>;
-    readonly shapeRenderOrderByIdSignal: Signal<Map<ShapeId, number>>;
-    readonly culledShapeIdSetSignal: Signal<Set<ShapeId>>;
-    readonly selectedShapeIdsOutsideCulledSignal: Signal<ShapeId[]>;
-    readonly selectedShapeIdsOutsideCulledSetSignal: Signal<Set<ShapeId>>;
-    readonly renderVisibleShapeIdSetSignal: Signal<Set<ShapeId>>;
-    private readonly shapeSignals;
-    private readonly shapeContentCutoutLocalPolygonSignals;
-    private readonly shapeSelectedSignals;
-    private readonly shapeRenderOrderSignals;
-    private readonly shapeRenderVisibleSignals;
-    private readonly shapeDocumentVisibleSignals;
-    private readonly shapeEffectiveOpacitySignals;
-    private readonly shapeEditingSessionSignals;
-    private readonly shapeDropTargetSignals;
-    private readonly shapeHoveredSignals;
-    private readonly shapeSelectedDescendantTransformAncestorSignals;
-    private lastPointerDownForClickCount;
-    private lastPointerUpForClickCount;
-    private currentPointerClickCount;
-    readonly selectionOverlayFrameGeometrySignal: Signal<SelectionOverlayFrameGeometryState | null>;
-    readonly selectionOverlayCompanionFrameGeometriesSignal: Signal<SelectionOverlayFrameGeometryState[]>;
-    readonly selectionOverlayPathSignal: Signal<string | null>;
-    readonly selectionOverlayPageClipPathSignal: Signal<string | null>;
-    readonly selectionOverlayBindingSegmentsSignal: Signal<SelectionBindingSegment[]>;
-    readonly selectionOverlayFrameStyleSignal: Signal<SelectionOverlayFrameStyleState>;
-    readonly selectionOverlayFrameSignal: Signal<SelectionOverlayFrameState | null>;
-    readonly selectionOverlayHandleAnchorsSignal: Signal<SelectionOverlayHandleAnchorsState | null>;
-    readonly selectionOverlayHandlesSignal: Signal<SelectionOverlayHandlesState | null>;
-    readonly selectionOverlayHandleCountsSignal: Signal<SelectionOverlayHandleCountsState | null>;
-    readonly selectionOverlaySignal: Signal<SelectionOverlayState | null>;
-    readonly overlayDebugStateSignal: Signal<EditorOverlayDebugState>;
+    private readonly _readonlySignal;
+    private writesClosed;
+    readonly document: {
+        readonly getMetadata: () => DocumentMetadataRecord | undefined;
+        readonly updateMetadata: (patch: Record<string, unknown>, source?: ChangeSource) => DocumentMetadataRecord;
+        readonly setReadonly: (readonly: boolean) => void;
+    };
+    readonly session: {
+        readonly get: () => SessionRecord;
+        readonly update: (partial: Partial<SessionRecord>, source?: ChangeSource) => void;
+    };
+    readonly pages: {
+        readonly getAll: () => PageRecord[];
+        readonly get: (id: PageId) => PageRecord | undefined;
+        readonly getCurrentId: () => PageId;
+        readonly createAndSelect: (input?: CreatePageInput, source?: ChangeSource) => PageRecord;
+        readonly select: (pageId: PageId, source?: ChangeSource) => void;
+        readonly rename: (pageId: PageId, name: string, source?: ChangeSource) => void;
+        readonly updateMetadata: (pageId: PageId, patch: Record<string, unknown>, source?: ChangeSource) => PageRecord | null;
+        readonly delete: (pageId: PageId, source?: ChangeSource) => boolean;
+    };
+    readonly selection: {
+        readonly getIds: (pageId?: PageId) => ShapeId[];
+        readonly set: (ids: ShapeId[], options?: {
+            pageId?: PageId;
+            source?: ChangeSource;
+        }) => void;
+        readonly remove: (ids: ShapeId[], source?: ChangeSource) => void;
+        readonly delete: (source?: ChangeSource) => void;
+        readonly createClipboardPayload: () => EditorClipboardPayload | null;
+        readonly pasteClipboardPayload: (input: PasteClipboardPayloadInput) => ShapeId[];
+        readonly duplicate: (input?: DuplicateSelectionInput) => ShapeId[];
+        readonly selectAll: (source?: ChangeSource) => void;
+        readonly resetRotation: (source?: ChangeSource) => void;
+        readonly flip: (axis: ShapeSelectionFlipAxis, source?: ChangeSource) => void;
+        readonly canAlign: () => boolean;
+        readonly align: (mode: "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom", source?: ChangeSource) => boolean;
+        readonly canDistribute: () => boolean;
+        readonly distribute: (axis: "horizontal" | "vertical", source?: ChangeSource) => boolean;
+        readonly canResize: () => boolean;
+        readonly canFlip: () => boolean;
+        readonly canRotate: () => boolean;
+        readonly getTransformTargets: () => ShapeRecord[];
+        readonly getResizeTargets: () => ShapeRecord[];
+        readonly getRotationTargets: () => ShapeRecord[];
+        readonly getPageBounds: () => Box | null;
+        readonly getFrame: () => SelectionFrame | null;
+        readonly containsPoint: (point: Vec) => boolean;
+        readonly toFramePoint: (point: Vec) => Vec | null;
+        readonly getPageOutlineVertices: () => Vec[];
+        readonly getAnchorPagePoint: () => Vec | null;
+        readonly getFrameBounds: () => Box | null;
+        readonly getRotationCenter: () => Vec | null;
+        readonly getRotation: () => number;
+        readonly hasCompatibleRotation: () => boolean;
+        readonly hitTestHandle: (point: Vec) => SelectionHandle | null;
+    };
+    readonly shapes: {
+        readonly get: (id: ShapeId) => ShapeRecord | undefined;
+        readonly getForPage: (pageId: PageId) => ShapeRecord[];
+        readonly getSignal: (id: ShapeId) => Signal<ShapeRecord | undefined>;
+        readonly getContentCutoutLocalPolygonsSignal: (id: ShapeId) => Signal<readonly (readonly Vec[])[]>;
+        readonly getLocalToPageTransformSignal: (id: ShapeId) => Signal<Mat | undefined>;
+        readonly getLocalToPageTransform: (id: ShapeId) => Mat | null;
+        readonly getPageBoundsSignal: (id: ShapeId) => Signal<Box | undefined>;
+        readonly getSelectedSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getRenderOrderSignal: (id: ShapeId) => Signal<number>;
+        readonly getRenderVisibleSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getDocumentVisibleSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getEffectiveOpacitySignal: (id: ShapeId) => Signal<number>;
+        readonly getEditingSessionSignal: (id: ShapeId) => Signal<ShapeEditingSession | null>;
+        readonly getDropTargetSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getHoveredSignal: (id: ShapeId) => Signal<boolean>;
+        readonly getSelectedDescendantTransformAncestorSignal: (id: ShapeId) => Signal<boolean>;
+        readonly isHidden: (shapeId: ShapeId) => boolean;
+        readonly getDefaultProps: <TProps extends object = object>(type: ShapeRecord["type"]) => TProps;
+        readonly updateDefaultProps: (type: ShapeRecord["type"], props: ShapePropsPatch) => void;
+        readonly delete: (ids: readonly ShapeId[], source?: ChangeSource) => void;
+        readonly setHidden: (ids: readonly ShapeId[], isHidden: boolean, source?: ChangeSource) => ShapeId[];
+        readonly setLocked: (ids: readonly ShapeId[], isLocked: boolean, source?: ChangeSource) => ShapeId[];
+        readonly getUtil: <S extends ShapeRecord>(shape: S) => ShapeUtil<S>;
+        readonly computePositionedBounds: (shape: ShapeRecord) => Box;
+        readonly computeLocalBounds: (shape: ShapeRecord) => Box;
+        readonly computeRenderBounds: (shape: ShapeRecord) => Box;
+        readonly computeExportBounds: (shape: ShapeRecord) => Box;
+        readonly computeLocalToPageTransform: (shape: ShapeRecord) => Mat;
+        readonly computeRenderToPageTransform: (shape: ShapeRecord) => Mat;
+        readonly computeExportToPageTransform: (shape: ShapeRecord) => Mat;
+        readonly computePageBounds: (shape: ShapeRecord) => Box;
+        readonly computeExportPageBounds: (shape: ShapeRecord) => Box;
+        readonly computeGeometry: (shape: ShapeRecord) => ShapeGeometry;
+        readonly computePositionedToPageTransform: (shape: ShapeRecord) => Mat;
+        readonly computePageCenter: (shape: ShapeRecord) => Vec;
+        readonly computePageCorners: (shape: ShapeRecord) => Vec[];
+        readonly computePageOutlineVertices: (shape: ShapeRecord) => Vec[];
+        readonly getPositionedBounds: (shapeId: ShapeId) => Box | null;
+        readonly getPageBounds: (shapeId: ShapeId) => Box | null;
+        readonly getGeometry: (shapeId: ShapeId) => ShapeGeometry | null;
+        readonly getPositionedToPageTransform: (shapeId: ShapeId) => Mat | null;
+        readonly getPageCenter: (shapeId: ShapeId) => Vec | null;
+        readonly getPageCorners: (shapeId: ShapeId) => Vec[] | null;
+        readonly getPageOutlineVertices: (shapeId: ShapeId) => Vec[];
+        readonly getClipAncestorIds: (shapeId: ShapeId) => ShapeId[];
+        readonly getClipAncestorIdsSignal: (shapeId: ShapeId) => Signal<ShapeId[]>;
+        readonly isPagePointInClip: (shapeId: ShapeId, point: Vec) => boolean;
+        readonly getClippedPageBounds: (shapeId: ShapeId) => Box | null;
+        readonly hitTest: (point: Vec) => ShapeRecord | null;
+        readonly hitTestPoint: (point: Vec, options?: ShapeAtPointOptions) => ShapeRecord[];
+        readonly hitTestLineSegment: (start: Vec, end: Vec, options?: ShapeLineSegmentHitTestOptions) => ShapeRecord[];
+        readonly getIdsInBounds: (bounds: Box, options?: SpatialQueryOptions) => ShapeId[];
+        readonly getInBounds: (bounds: Box, options?: SpatialQueryOptions) => ShapeRecord[];
+        readonly getInViewport: (bounds: Box, options?: SpatialQueryOptions) => ShapeRecord[];
+        readonly getIdsInViewport: (bounds: Box, options?: SpatialQueryOptions) => ShapeId[];
+    };
+    readonly layers: {
+        readonly getSelectionParentOrderState: () => ShapeSelectionSiblingOrderState | null;
+        readonly getSelectionGroupState: () => ShapeGroupState | null;
+        readonly canGroupSelection: () => boolean;
+        readonly canGroup: (ids: readonly ShapeId[]) => boolean;
+        readonly group: (ids: readonly ShapeId[], source?: ChangeSource) => ShapeRecord | null;
+        readonly groupSelection: (source?: ChangeSource) => ShapeRecord | null;
+        readonly getUngroupableSelectionIds: () => ShapeId[];
+        readonly getUngroupableIds: (ids: readonly ShapeId[]) => ShapeId[];
+        readonly canUngroupSelection: () => boolean;
+        readonly canUngroup: (ids: readonly ShapeId[]) => boolean;
+        readonly ungroup: (ids: readonly ShapeId[], source?: ChangeSource) => ShapeId[];
+        readonly ungroupSelection: (source?: ChangeSource) => ShapeId[];
+        readonly getSelectionSiblingOrderState: () => ShapeSiblingOrderState | null;
+        readonly canMoveSelectionWithinParent: (direction: ShapeSiblingOrderDirection) => boolean;
+        readonly canMoveSelection: (direction: ShapeSiblingOrderDirection) => boolean;
+        readonly canMove: (ids: readonly ShapeId[], direction: LayerOrderDirection) => boolean;
+        readonly move: (ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource) => boolean;
+        readonly moveToEdge: (ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource) => boolean;
+        readonly moveSelectionWithinParent: (direction: ShapeSiblingOrderDirection, source?: ChangeSource) => boolean;
+        readonly moveToPlacement: (input: ReparentShapePlacementInput, source?: ChangeSource) => ReparentShapePlacementResult;
+        readonly moveSelection: (direction: ShapeSiblingOrderDirection, source?: ChangeSource) => boolean;
+        readonly moveSelectionToEdge: (edge: ShapeSiblingOrderEdge, source?: ChangeSource) => boolean;
+        readonly getChildIds: (parentId: ShapeParentId) => ShapeId[];
+        readonly getChildren: (parentId: ShapeParentId) => ShapeRecord[];
+        readonly getDescendantIds: (parentId: ShapeParentId) => ShapeId[];
+        readonly getDescendantPageBounds: (parentId: ShapeParentId) => Box | null;
+        readonly getSubtreePageBounds: (shapeId: ShapeId) => Box | null;
+        readonly getPageId: (shapeId: ShapeId) => PageId | null;
+        readonly isOrAncestorLocked: (shapeId: ShapeId) => boolean;
+        readonly isOrAncestorInSet: (shapeId: ShapeId, ids: ReadonlySet<ShapeId>) => boolean;
+        readonly hasLockedDescendant: (shapeId: ShapeId) => boolean;
+        readonly getOutermostSelectableId: (shapeId: ShapeId) => ShapeId;
+        readonly includeDescendants: (shapeIds: Iterable<ShapeId>) => ShapeId[];
+        readonly getSelectionTransformIds: (shapeIds: Iterable<ShapeId>) => ShapeId[];
+        readonly getSelectionRotationIds: (shapeIds: Iterable<ShapeId>) => ShapeId[];
+        readonly getExportTraversalIds: (shapeIds: Iterable<ShapeId>) => ShapeId[];
+        readonly getContainment: (containerId: ShapeId, shapeId: ShapeId) => ShapeContainment | null;
+        readonly getContainingParentId: (shapeIds: Iterable<ShapeId>) => ShapeParentId | null;
+        readonly getContainingParentIdAtPoint: (shapeIds: Iterable<ShapeId>, point: Vec) => ShapeParentId | null;
+        readonly getContainingParentIdForShape: (shape: ShapeRecord) => ShapeParentId | null;
+        readonly getIdsInContainerBounds: (containerId: ShapeId, options?: ContainerBoundsQueryOptions) => ShapeId[];
+        readonly canReceiveChildren: (parentId: ShapeParentId) => boolean;
+        readonly canReceiveChild: (parentId: ShapeParentId, childId: ShapeId) => boolean;
+    };
+    readonly assets: {
+        readonly get: (id: AssetId) => AssetRecord | undefined;
+        readonly getAll: () => AssetRecord[];
+        readonly resolveUrl: (assetId: AssetId) => string | null;
+    };
+    readonly bindings: {
+        readonly get: (id: BindingId) => BindingRecord | undefined;
+        readonly getFromShape: (shapeId: ShapeId) => BindingRecord[];
+        readonly getFromShapeSignal: (shapeId: ShapeId) => Signal<readonly BindingRecord[]>;
+        readonly getToShape: (shapeId: ShapeId) => BindingRecord[];
+        readonly getToShapeSignal: (shapeId: ShapeId) => Signal<readonly BindingRecord[]>;
+        readonly getForShape: (shapeId: ShapeId) => BindingRecord[];
+        readonly getForShapeSignal: (shapeId: ShapeId) => Signal<readonly BindingRecord[]>;
+        readonly getUtil: <B extends BindingRecord>(binding: B) => BindingUtil<B>;
+        readonly getSuppressedReactionIds: () => ReadonlySet<BindingId>;
+        readonly runWithSuppressedReactions: <T>(bindingIds: Iterable<BindingId>, callback: () => T) => T;
+        readonly getConflicting: (binding: BindingRecord) => BindingRecord[];
+        readonly canBind: (binding: BindingRecord) => boolean;
+        readonly syncCreated: (binding: BindingRecord, source: ChangeSource) => void;
+        readonly syncUpdated: (before: BindingRecord, after: BindingRecord, source: ChangeSource) => void;
+        readonly repairLoaded: (source: ChangeSource) => void;
+        readonly handleShapeChanges: (changes: Parameters<BindingManager["handleShapeChanges"]>[0], source: ChangeSource) => void;
+        readonly getShapeCompanionRootId: (shapeId: ShapeId) => ShapeId;
+        readonly getShapeCompanionRootIds: (shapeIds: readonly ShapeId[], records?: readonly BindingRecord[]) => ReadonlyMap<ShapeId, ShapeId>;
+        readonly getShapeCompanionMemberIds: (shapeIds: readonly ShapeId[]) => ShapeId[];
+        readonly cleanupForDeletedShapes: (shapeIds: readonly ShapeId[], source: ChangeSource) => void;
+        readonly cleanup: (bindingIds: Iterable<BindingId>, source: ChangeSource) => void;
+        readonly setTerminalResolver: (resolver: TerminalBindingResolver) => void;
+        readonly resolveTerminal: (input: TerminalBindingResolverInput) => ResolvedTerminalBinding;
+    };
+    readonly viewport: {
+        readonly getCamera: (pageId?: PageId) => Camera;
+        readonly pageToScreen: (point: Vec, pageId?: PageId) => Vec;
+        readonly screenToPage: (point: Vec, pageId?: PageId) => Vec;
+        readonly setCamera: (partial: Partial<Camera>, options?: {
+            pageId?: PageId;
+            source?: ChangeSource;
+        }) => void;
+        readonly pan: (delta: Vec, source?: ChangeSource) => void;
+        readonly zoomAtScreenPoint: (screenPoint: Vec, deltaY: number, source?: ChangeSource) => void;
+        readonly zoomToScreenPoint: (screenPoint: Vec, zoom: number, source?: ChangeSource) => void;
+        readonly zoomAtCenter: (deltaY: number, source?: ChangeSource) => void;
+        readonly resetZoom: (source?: ChangeSource) => void;
+        readonly setScreenSize: (size: {
+            w: number;
+            h: number;
+        }) => void;
+        readonly stopCameraAnimation: () => void;
+        readonly getCurrentPageBounds: (pageId?: PageId) => Box | null;
+        readonly centerOnShape: (shapeId: ShapeId, options?: CenterOnShapeOptions) => boolean;
+        readonly zoomToBounds: (bounds: Box, options?: {
+            padding?: number;
+            maxZoom?: number;
+            source?: ChangeSource;
+        }) => boolean;
+        readonly zoomToFit: (options?: {
+            padding?: number;
+            source?: ChangeSource;
+        }) => boolean;
+        readonly zoomToSelection: (options?: {
+            padding?: number;
+            source?: ChangeSource;
+        }) => boolean;
+    };
+    readonly interaction: {
+        readonly setBrushBox: (brushBox: Box | null) => void;
+        readonly setBindingPreview: (preview: BindingPreviewState | null) => void;
+        readonly setTerminalBindingGuides: (guides: readonly TerminalBindingGuideState[] | null) => void;
+        readonly setDropTargetShapeId: (shapeId: ShapeId | null) => void;
+        readonly setHoveredShapeId: (shapeId: ShapeId | null) => void;
+        readonly setSelectionTranslationActive: (active: boolean) => void;
+        readonly setSnapIndicators: (indicators: SnapIndicatorState[] | null) => void;
+        readonly clearSelection: () => void;
+        readonly cancelForCommand: () => void;
+        readonly cancel: (reason: CancelEditorEvent["reason"], options?: {
+            notifyInteractionHandlers?: boolean;
+        }) => void;
+    };
+    readonly snapshots: {
+        readonly getDocument: () => DocumentSnapshot;
+        readonly getSession: () => SessionSnapshot;
+        readonly loadDocument: (snapshot: unknown, options?: {
+            source?: ChangeSource;
+        }) => void;
+        readonly loadSession: (snapshot: unknown, options?: {
+            source?: ChangeSource;
+        }) => void;
+        readonly syncAfterDocumentRestore: () => void;
+    };
+    readonly exports: {
+        readonly getSvgString: (shapeIds?: Iterable<ShapeId>, options?: Parameters<typeof exportShapesToSvgString>[3]) => import("..").SvgExportResult | null;
+        readonly getIntegrityReport: (shapeIds?: Iterable<ShapeId>) => import("..").ExportIntegrityReport;
+        readonly repairIntegrity: (shapeIds?: Iterable<ShapeId>) => import("..").ExportIntegrityRepairResult;
+    };
     constructor(options?: EditorOptions);
+    closeWrites(): void;
+    assertDocumentWriteAllowed(): void;
+    private assertStoreChangeAllowed;
     private registerBuiltInInteractions;
-    private registerBuiltInShortcuts;
-    private registerBuiltInSideEffects;
-    dispatch(event: EditorEvent): void;
-    handleInteractionEvent(event: EditorEvent): boolean;
-    private runKeyboardShortcutTarget;
-    private runEditorKeyboardShortcut;
-    private normalizeEvent;
-    private getDoubleClickEvent;
+    handleEvent(event: EditorEvent): EditorEventResult;
     listen(listener: (change: StoreChange<EditorRecord>) => void): () => void;
-    getRenderItems(): RenderItem[];
-    getPages(): PageRecord[];
-    getDocumentMetadataRecord(): DocumentMetadataRecord | undefined;
-    getCurrentPageId(): PageId;
-    getActiveToolId(): string;
-    isToolLocked(): boolean;
-    isActiveToolInInitialState(): boolean;
-    getEditingShapeId(): ShapeId | null;
-    getShapeEditingSession(): ShapeEditingSession | null;
-    getShapeEditingEntryRequest(): ShapeEditingEntryRequest | null;
-    resetPointerClickTracking(): void;
-    getCurrentPageShapeIds(): ShapeId[];
-    getPage(id: PageId): PageRecord | undefined;
-    getCurrentCamera(): Camera;
-    undo(): boolean;
-    redo(): boolean;
-    createPageAndSelect(input?: CreatePageInput, source?: ChangeSource): PageRecord;
-    selectPage(pageId: PageId, source?: ChangeSource): void;
-    renamePage(pageId: PageId, name: string, source?: ChangeSource): void;
-    updateDocumentMeta(patch: Record<string, unknown>, source?: ChangeSource): DocumentMetadataRecord;
-    updatePageMeta(pageId: PageId, patch: Record<string, unknown>, source?: ChangeSource): PageRecord | null;
-    deletePage(pageId: PageId, source?: ChangeSource): boolean;
-    setActiveTool(toolId: string, source?: ChangeSource): void;
-    setToolLocked(locked: boolean, source?: ChangeSource): void;
-    toggleToolLocked(source?: ChangeSource): void;
-    getCamera(pageId?: PageId): Camera;
-    pageToScreen(point: Vec, pageId?: PageId): Vec;
-    screenToPage(point: Vec, pageId?: PageId): Vec;
-    getSelectedShapeIds(pageId?: PageId): ShapeId[];
-    isShapeHidden(shapeId: ShapeId): boolean;
-    getSelectedShapes(): ShapeRecord[];
-    getDefaultShapeProps<TProps extends object = object>(type: ShapeRecord["type"]): TProps;
-    updateDefaultShapeProps(type: ShapeRecord["type"], props: ShapePropsPatch): void;
-    getSelectionParentOrderState(): ShapeSelectionSiblingOrderState | null;
-    getSelectionGroupState(): ShapeGroupState | null;
-    canGroupSelection(): boolean;
-    canGroupShapes(ids: readonly ShapeId[]): boolean;
-    groupShapes(ids: readonly ShapeId[], source?: ChangeSource): ShapeRecord | null;
-    groupSelection(source?: ChangeSource): ShapeRecord | null;
-    getUngroupableSelectedShapeIds(): ShapeId[];
-    getUngroupableShapeIds(ids: readonly ShapeId[]): ShapeId[];
-    canUngroupSelection(): boolean;
-    canUngroupShapes(ids: readonly ShapeId[]): boolean;
-    ungroupShapes(ids: readonly ShapeId[], source?: ChangeSource): ShapeId[];
-    ungroupSelection(source?: ChangeSource): ShapeId[];
-    getSelectionSiblingOrderState(): ShapeSiblingOrderState | null;
-    canMoveSelectionWithinParent(direction: ShapeSiblingOrderDirection): boolean;
-    canMoveSelectionInParentOrder(direction: ShapeSiblingOrderDirection): boolean;
-    canMoveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection): boolean;
-    moveShapesInParentOrder(ids: readonly ShapeId[], direction: LayerOrderDirection, source?: ChangeSource): boolean;
-    moveShapesToParentOrderEdge(ids: readonly ShapeId[], edge: LayerOrderEdge, source?: ChangeSource): boolean;
-    moveSelectionWithinParent(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
-    canAlignSelection(): boolean;
-    /**
-     * Align selected, unlocked siblings along an edge or center of their combined
-     * page bounds. Needs at least two eligible shapes.
-     */
-    alignSelection(mode: "left" | "horizontal-center" | "right" | "top" | "vertical-center" | "bottom", source?: ChangeSource): boolean;
-    canDistributeSelection(): boolean;
-    /**
-     * Distribute selected, unlocked siblings so the gaps between them are equal
-     * along the given axis. Needs at least three eligible shapes.
-     */
-    distributeSelection(axis: "horizontal" | "vertical", source?: ChangeSource): boolean;
-    moveShapesToParentPlacementResult(input: ReparentShapePlacementInput, source?: ChangeSource): ReparentShapePlacementResult;
-    moveSelectionInParentOrder(direction: ShapeSiblingOrderDirection, source?: ChangeSource): boolean;
-    moveSelectionToParentOrderEdge(edge: ShapeSiblingOrderEdge, source?: ChangeSource): boolean;
-    canEditShape(shapeOrId: ShapeRecord | ShapeId | null | undefined): boolean;
-    startEditingShape(input: StartEditingShapeInput, source?: ChangeSource): ShapeEditingSession | null;
-    completeEditing(source?: ChangeSource): boolean;
-    cancelEditing(source?: ChangeSource): boolean;
-    setShapeEditingComposition(isComposing: boolean, source?: ChangeSource): void;
-    consumeShapeEditingEntryRequest(requestId: number): void;
-    deleteSelection(source?: ChangeSource): void;
-    deleteShapesById(ids: readonly ShapeId[], source?: ChangeSource): void;
-    setShapesHidden(ids: readonly ShapeId[], isHidden: boolean, source?: ChangeSource): ShapeId[];
-    setShapesLocked(ids: readonly ShapeId[], isLocked: boolean, source?: ChangeSource): ShapeId[];
-    createClipboardPayloadFromSelection(): EditorClipboardPayload | null;
-    pasteClipboardPayload(input: PasteClipboardPayloadInput): ShapeId[];
-    duplicateSelection(input?: DuplicateSelectionInput): ShapeId[];
-    selectAllCurrentPage(source?: ChangeSource): void;
-    resetSelectionRotation(source?: ChangeSource): void;
-    flipSelection(axis: ShapeSelectionFlipAxis, source?: ChangeSource): void;
-    getShape(id: ShapeId): ShapeRecord | undefined;
-    getAsset(id: AssetId): AssetRecord | undefined;
-    getAssets(): AssetRecord[];
-    resolveAssetUrl(assetId: AssetId): string | null;
-    getUnreferencedAssetIdsAfterShapeDelete(shapeIds: readonly ShapeId[]): AssetId[];
-    getShapeSignal(id: ShapeId): Signal<ShapeRecord | undefined>;
-    getShapeContentCutoutLocalPolygonsSignal(id: ShapeId): Signal<readonly (readonly Vec[])[]>;
-    getShapeLocalToPageTransformSignal(id: ShapeId): Signal<Mat | undefined>;
-    getShapeSelectedSignal(id: ShapeId): Signal<boolean>;
-    getShapeRenderOrderSignal(id: ShapeId): Signal<number>;
-    getShapeRenderVisibleSignal(id: ShapeId): Signal<boolean>;
-    getShapeDocumentVisibleSignal(id: ShapeId): Signal<boolean>;
-    getShapeEffectiveOpacitySignal(id: ShapeId): Signal<number>;
-    getShapeEditingSessionForShapeSignal(id: ShapeId): Signal<ShapeEditingSession | null>;
-    getShapeDropTargetSignal(id: ShapeId): Signal<boolean>;
-    getShapeHoveredSignal(id: ShapeId): Signal<boolean>;
-    getShapeSelectedDescendantTransformAncestorSignal(id: ShapeId): Signal<boolean>;
-    getBinding(id: BindingId): BindingRecord | undefined;
-    getShapesForPage(pageId: PageId): ShapeRecord[];
-    getBindingsFromShape(shapeId: ShapeId): BindingRecord[];
-    getBindingsFromShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
-    getBindingsToShape(shapeId: ShapeId): BindingRecord[];
-    getBindingsToShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
-    getBindingsForShape(shapeId: ShapeId): BindingRecord[];
-    getBindingsForShapeSignal(shapeId: ShapeId): Signal<readonly BindingRecord[]>;
-    getChildShapeIds(parentId: ShapeParentId): ShapeId[];
-    getChildShapes(parentId: ShapeParentId): ShapeRecord[];
-    getDescendantShapeIds(parentId: ShapeParentId): ShapeId[];
-    getDescendantPageBounds(parentId: ShapeParentId): Box | null;
-    getShapeSubtreePageBounds(shapeId: ShapeId): Box | null;
-    getShapePageId(shapeId: ShapeId): PageId | null;
-    isShapeOrAncestorLocked(shapeId: ShapeId): boolean;
-    hasLockedDescendant(shapeId: ShapeId): boolean;
-    getOutermostSelectableShapeId(shapeId: ShapeId): ShapeId;
-    getShapeIdsIncludingDescendants(shapeIds: Iterable<ShapeId>): ShapeId[];
-    getShapeIdsForSelectionTransform(shapeIds: Iterable<ShapeId>): ShapeId[];
-    getShapeIdsForSelectionRotation(shapeIds: Iterable<ShapeId>): ShapeId[];
-    getSelectionTransformTargetShapes(): ShapeRecord[];
-    canResizeSelection(): boolean;
-    canFlipSelection(): boolean;
-    canRotateSelection(): boolean;
-    getSelectionResizeTargetShapes(): ShapeRecord[];
-    getSelectionRotationTargetShapes(): ShapeRecord[];
-    getShapeExportTraversalIds(shapeIds: Iterable<ShapeId>): ShapeId[];
-    getShapeContainment(containerId: ShapeId, shapeId: ShapeId): ShapeContainment | null;
-    getContainingShapeParentId(shapeIds: Iterable<ShapeId>): ShapeParentId | null;
-    getContainingShapeParentIdAtPoint(shapeIds: Iterable<ShapeId>, point: Vec): ShapeParentId | null;
-    getContainingParentIdForShapeRecord(shape: ShapeRecord): ShapeParentId | null;
-    getShapeClipAncestorIds(shapeId: ShapeId): ShapeId[];
-    getShapeClipAncestorIdsSignal(shapeId: ShapeId): Signal<ShapeId[]>;
-    isPagePointInShapeClip(shapeId: ShapeId, point: Vec): boolean;
-    getShapeClippedPageBounds(shapeId: ShapeId): Box | null;
-    getShapeIdsInContainerBounds(containerId: ShapeId, options?: ContainerBoundsQueryOptions): ShapeId[];
-    canUseShapeParent(parentId: ShapeParentId, childId?: ShapeId): boolean;
-    getShapeUtil<S extends ShapeRecord>(shape: S): ShapeUtil<S>;
-    getBindingUtil<B extends BindingRecord>(binding: B): BindingUtil<B>;
-    computeShapePositionedBounds(shape: ShapeRecord): Box;
-    computeShapeLocalBounds(shape: ShapeRecord): Box;
-    computeShapeRenderBounds(shape: ShapeRecord): Box;
-    computeShapeExportBounds(shape: ShapeRecord): Box;
-    computeShapeLocalToPageTransform(shape: ShapeRecord): Mat;
-    computeShapeRenderToPageTransform(shape: ShapeRecord): Mat;
-    computeShapeExportToPageTransform(shape: ShapeRecord): Mat;
-    computeShapePageBounds(shape: ShapeRecord): Box;
-    computeShapeExportPageBounds(shape: ShapeRecord): Box;
-    computeShapeGeometry(shape: ShapeRecord): ShapeGeometry;
-    computeShapePositionedToPageTransform(shape: ShapeRecord): Mat;
-    computeShapePageCenter(shape: ShapeRecord): Vec;
-    computeShapePageCorners(shape: ShapeRecord): Vec[];
-    computeShapePageOutlineVertices(shape: ShapeRecord): Vec[];
-    getShapePositionedBounds(shapeId: ShapeId): Box | null;
-    getShapePageBounds(shapeId: ShapeId): Box | null;
-    getShapeGeometry(shapeId: ShapeId): ShapeGeometry | null;
-    getShapePositionedToPageTransform(shapeId: ShapeId): Mat | null;
-    getShapePageCenter(shapeId: ShapeId): Vec | null;
-    getShapePageCorners(shapeId: ShapeId): Vec[] | null;
-    getShapePageOutlineVertices(shapeId: ShapeId): Vec[];
-    getSelectionPageBounds(): Box | null;
-    getSelectionFrame(): SelectionFrame | null;
-    isPointInSelectionBounds(point: Vec): boolean;
-    getSelectionFrameLocalBoundsPoint(point: Vec): Vec | null;
-    getSelectionPageOutlineVertices(): Vec[];
-    getSelectionAnchorPagePoint(): Vec | null;
-    hitTestSelectionHandle(point: Vec): SelectionHandle | null;
-    setBrushBox(brushBox: Box | null): void;
-    setBindingPreview(preview: BindingPreviewState | null): void;
-    setTerminalBindingGuides(guides: readonly TerminalBindingGuideState[] | null): void;
-    setDropTargetShapeId(shapeId: ShapeId | null): void;
-    setHoveredShapeId(shapeId: ShapeId | null): void;
-    setSelectionTranslationActive(active: boolean): void;
-    setSnapIndicators(indicators: SnapIndicatorState[] | null): void;
-    setTerminalBindingResolver(resolver: TerminalBindingResolver): void;
-    resolveTerminalBinding(input: TerminalBindingResolverInput): ResolvedTerminalBinding;
-    clearSelectionTransients(): void;
-    hitTestShape(point: Vec): ShapeRecord | null;
-    hitTestShapesAtPoint(point: Vec, options?: ShapeAtPointOptions): ShapeRecord[];
-    hitTestShapesByLineSegment(start: Vec, end: Vec, options?: ShapeLineSegmentHitTestOptions): ShapeRecord[];
-    getShapeIdsInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeId[];
-    getShapesInBounds(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
-    getShapesInViewport(bounds: Box, options?: SpatialQueryOptions): ShapeRecord[];
-    getDocumentSnapshot(): DocumentSnapshot;
-    getSessionSnapshot(): SessionSnapshot;
-    getSvgString(shapeIds?: Iterable<ShapeId>, options?: SvgExportOptions): SvgExportResult | null;
-    getExportIntegrityReport(shapeIds?: Iterable<ShapeId>): ExportIntegrityReport;
-    repairExportIntegrity(shapeIds?: Iterable<ShapeId>): ExportIntegrityRepairResult;
-    getShapeCapabilityManifest(): ShapeCapabilityManifest;
-    createPageRecord(input?: {
-        name?: string;
-        index?: string;
-        meta?: Record<string, unknown>;
-    }): PageRecord;
-    loadDocumentSnapshot(snapshot: unknown, options?: {
-        source?: ChangeSource;
-    }): void;
-    loadSessionSnapshot(snapshot: unknown, options?: {
-        source?: ChangeSource;
-    }): void;
-    syncAfterDocumentRestore(): void;
-    cancelInteractionForCommand(): void;
-    cancelInteractionAndClearTransients(reason: CancelEditorEvent["reason"], options?: {
-        notifyInteractionHandlers?: boolean;
-    }): void;
-    syncToolStateFromSession(source: ChangeSource): void;
-    createShapeRecord(input: CreateShapeInput): ShapeRecord;
-    createBindingRecord(input: CreateBindingInput): BindingRecord;
-    createAssetRecord(input: CreateAssetInput): AssetRecord;
-    updateSession(partial: Partial<SessionRecord>, source?: ChangeSource): void;
-    setCurrentPage(pageId: PageId, source?: ChangeSource): void;
-    setSelectedShapeIds(ids: ShapeId[], options?: {
-        pageId?: PageId;
-        source?: ChangeSource;
-    }): void;
-    removeShapeIdsFromSelection(ids: ShapeId[], source?: ChangeSource): void;
-    removeShapeIdsFromEditingSession(ids: ShapeId[], source?: ChangeSource): void;
-    prepareShapeIdsForRemoval(ids: readonly ShapeId[], source?: ChangeSource): void;
-    ensurePageSessionState(pageId: PageId, source?: ChangeSource): void;
-    removePageSessionState(pageId: PageId, nextCurrentPageId: PageId, source?: ChangeSource): void;
-    setCamera(partial: Partial<Camera>, options?: {
-        pageId?: PageId;
-        source?: ChangeSource;
-    }): void;
-    panCamera(delta: Vec, source?: ChangeSource): void;
-    zoomCameraAtScreenPoint(screenPoint: Vec, deltaY: number, source?: ChangeSource): void;
-    zoomCameraToScreenPoint(screenPoint: Vec, zoom: number, source?: ChangeSource): void;
-    zoomAtViewportCenter(deltaY: number, source?: ChangeSource): void;
-    resetZoom(source?: ChangeSource): void;
-    setViewportScreenSize(size: {
-        w: number;
-        h: number;
-    }): void;
-    /** Combined page bounds of every shape on a page, or null when empty. */
-    getCurrentPageBounds(pageId?: PageId): Box | null;
-    /**
-     * Move and zoom the camera so `bounds` fits inside the viewport with optional
-     * padding (screen px). Returns false when the viewport or bounds are empty.
-     */
-    zoomToBounds(bounds: Box, options?: {
-        padding?: number;
-        maxZoom?: number;
-        source?: ChangeSource;
-    }): boolean;
-    /** Fit all shapes on the current page into the viewport. */
-    zoomToFit(options?: {
-        padding?: number;
-        source?: ChangeSource;
-    }): boolean;
-    /** Fit the current selection into the viewport. */
-    zoomToSelection(options?: {
-        padding?: number;
-        source?: ChangeSource;
-    }): boolean;
-    private createShapeId;
-    createShapeIndex(shapeNumber: number): string;
-    private createBindingId;
-    private createAssetId;
-    syncShapeCounter(): void;
-    syncPageCounter(): void;
-    syncBindingCounter(): void;
-    syncAssetCounter(): void;
     dispose(): void;
-    private createPageId;
-    private createPageIndex;
-    private handleWheelEvent;
 }
 export {};