@hy-bricks/canvas 0.4.3 → 0.6.0

package/dist/index.d.ts

@@ -10,8 +10,6 @@ import { Ref } from 'vue';
 import { ShallowRef } from 'vue';
 import { VNode } from 'vue';
 
-export declare function __resetRendererDiagnosticsRegistry(): void;
-
 declare const __VLS_component: DefineComponent<__VLS_Props_2, {
 context: CanvasContext;
 handle: CanvasHandle & {
@@ -46,6 +44,8 @@ parentLayoutMode: ContainerLayoutConfig["mode"];
 "onHandle-ready"?: ((handle: CanvasHandle) => any) | undefined;
 }>, {
 mode: CanvasMode;
+freeSplitEnabled: boolean | (() => boolean);
+cascadeRemove: boolean;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {
 stageContainerEl: HTMLDivElement;
 }, any>;
@@ -96,6 +96,8 @@ declare type __VLS_Props_2 = {
     schedulerOptions?: RenderSchedulerOptions;
     adapters?: CanvasAdapters;
     canvasId?: string;
+    freeSplitEnabled?: boolean | (() => boolean);
+    cascadeRemove?: boolean;
 };
 
 declare type __VLS_Props_3 = {
@@ -133,6 +135,16 @@ declare function __VLS_template(): {
                 isDragging: boolean;
             };
         }) => VNode[];
+        'free-split-divider'?: (props: {
+            state: {
+                containerId: string;
+                nodeId: string;
+                dividerIndex: number;
+                direction: "horizontal" | "vertical";
+                rect: Rect;
+                isDragging: boolean;
+            };
+        }) => VNode[];
     }> & {
         default?: () => VNode[];
         'canvas-overlay'?: (props: {
@@ -155,6 +167,16 @@ declare function __VLS_template(): {
                 isDragging: boolean;
             };
         }) => VNode[];
+        'free-split-divider'?: (props: {
+            state: {
+                containerId: string;
+                nodeId: string;
+                dividerIndex: number;
+                direction: "horizontal" | "vertical";
+                rect: Rect;
+                isDragging: boolean;
+            };
+        }) => VNode[];
     };
     refs: {
         stageContainerEl: HTMLDivElement;
@@ -192,6 +214,16 @@ declare function __VLS_template_3(): {
                 isDragging: boolean;
             };
         }) => unknown;
+        'free-split-divider'?: (props: {
+            state: {
+                containerId: string;
+                nodeId: string;
+                dividerIndex: number;
+                direction: "horizontal" | "vertical";
+                rect: Rect;
+                isDragging: boolean;
+            };
+        }) => unknown;
     }> & {
         'reparent-ghost'?: (props: {
             state: {
@@ -209,6 +241,16 @@ declare function __VLS_template_3(): {
                 isDragging: boolean;
             };
         }) => unknown;
+        'free-split-divider'?: (props: {
+            state: {
+                containerId: string;
+                nodeId: string;
+                dividerIndex: number;
+                direction: "horizontal" | "vertical";
+                rect: Rect;
+                isDragging: boolean;
+            };
+        }) => unknown;
     };
     refs: {
         layerEl: HTMLDivElement;
@@ -242,11 +284,9 @@ declare type __VLS_WithTemplateSlots_3<T, S> = T & {
 
 export declare function applyEffectiveSplitRatiosToDocument(doc: PageDocument): PageDocument;
 
-export declare function applySplitDividerDrag(startRatios: readonly number[], dividerIndex: number, deltaPx: number, parentAxisPx: number, gap?: number): number[];
-
-export declare function assertNeverBindingSource(s: never): never;
+export declare function applyFreeSplitResizeDrag(startSizes: readonly NodeSize[], dividerIndex: number, deltaPx: number, branchAxisPx: number, opts?: FreeSplitResizeOpts): NodeSize[];
 
-export declare function assertNeverBindingTarget(t: never): never;
+export declare function applySplitDividerDrag(startRatios: readonly number[], dividerIndex: number, deltaPx: number, parentAxisPx: number, gap?: number): number[];
 
 export declare interface AssetRef {
     id: string;
@@ -451,7 +491,7 @@ export declare const CANVAS_CONTEXT_KEY: InjectionKey<CanvasContext>;
 
 export declare const CANVAS_REPARENT_BRIDGE_KEY: InjectionKey<ReparentBridge>;
 
-export declare type CanvasAction = CanvasDocumentAction | CanvasSelectionAction;
+export declare type CanvasAction = CanvasDocumentAction | CanvasSelectionAction | CanvasFreeSplitAction;
 
 export declare interface CanvasActionHooks {
     onBeforeAction?: (action: CanvasAction) => boolean | void;
@@ -502,6 +542,8 @@ export declare interface CanvasContext {
     endBatch(batchType?: string): void;
     registerHooks(hooks: CanvasActionHooks): () => void;
     readonly isRecordingSuppressed: ComputedRef<boolean>;
+    readonly freeSplitEnabled: ComputedRef<boolean>;
+    readonly cascadeRemove: boolean;
     suppressRecording<T>(fn: () => T): T;
     readonly effectiveBehavior: ComputedRef<CanvasBehaviorConfig>;
     readonly interactionOptions: ComputedRef<Readonly<Partial<InteractionOptions>>>;
@@ -535,6 +577,8 @@ export declare interface CanvasContextOptions {
     adapters?: CanvasAdapters;
     hooks?: CanvasActionHooks;
     getMode?: () => CanvasMode;
+    freeSplitEnabled?: boolean | (() => boolean | undefined);
+    cascadeRemove?: boolean;
 }
 
 export declare type CanvasDocumentAction = {
@@ -598,7 +642,7 @@ export declare type CanvasDocumentAction = {
 } | {
     type: 'setRootLayout';
     payload: {
-        rootLayout: ContainerLayoutConfig | null;
+        rootLayout: RootContainerLayoutConfig | null;
     };
 } | {
     type: 'replaceDocument';
@@ -665,6 +709,8 @@ export declare interface CanvasFeatures {
     enablePublish?: boolean;
 }
 
+declare type CanvasFreeSplitAction = FreeSplitMutateAction;
+
 export declare interface CanvasGridConfig {
     visible?: boolean;
     size?: number;
@@ -687,14 +733,20 @@ export declare interface CanvasHandle {
     endBatch(batchType?: string): void;
     readonly isBatching: Readonly<Ref<boolean>>;
     getSnapshot(): PageDocument;
+    getRemoveImpact(instanceId: string): RemoveImpact;
     readonly selectedIds: Readonly<Ref<readonly string[]>>;
     readonly selectedInstances: ComputedRef<readonly PageInstance[]>;
+    readonly freeSplitSelection: Readonly<Ref<FreeSplitSelection | null>>;
+    selectFreeSplitLeaf(containerId: string, leafId: string): void;
+    selectFreeSplitDivider(containerId: string, nodeId: string, dividerIndex: number): void;
+    clearFreeSplitSelection(): void;
     readonly viewport: ViewportStore;
     clientToCanvasPoint(point: Point): Point;
     getInstanceAtClientPoint(point: Point): PageInstance | null;
     getDropTarget(point: Point, root?: ParentNode | null, options?: {
         excludeInstanceId?: string;
     }): DropTarget | null;
+    getFreeSplitDropTarget(point: Point, root?: ParentNode | null): FreeSplitDropTarget | null;
     duplicateInstance(instanceId: string, options?: DuplicateInstanceOptions): string | null;
     undo(): void;
     redo(): void;
@@ -708,7 +760,7 @@ export declare interface CanvasHandle {
     updateCanvasBackground(bg: Partial<CanvasBackgroundConfig> | null): void;
     updateBehavior(behavior: Partial<CanvasBehaviorConfig>): void;
     setInteractionOptions(options: Partial<InteractionOptions>): void;
-    setRootLayout(mode: ContainerLayoutConfig | 'free' | 'split' | 'grid' | 'flex' | 'none' | null): void;
+    setRootLayout(mode: RootContainerLayoutConfig | 'free' | 'split' | 'grid' | 'flex' | 'none' | null): void;
     getEffectiveBehavior(): CanvasBehaviorConfig;
     getInstanceTree(): PageInstanceTreeNode[];
     getInstanceList(): PageInstance[];
@@ -723,11 +775,11 @@ export declare interface CanvasHandle {
     readonly cannotReparentEvent: Readonly<Ref<CannotReparentEvent | null>>;
     readonly cannotDragLayoutManagedChildEvent: Readonly<Ref<CannotDragLayoutManagedChildEvent | null>>;
     getViewportState(): ViewportState;
-    getVisibleBounds(): Rect_2;
-    getCanvasBounds(): Rect_2;
-    getContentBounds(): Rect_2 | null;
-    getSelectionBounds(): Rect_2 | null;
-    getInstanceBounds(instanceId: string): Rect_2 | null;
+    getVisibleBounds(): Rect;
+    getCanvasBounds(): Rect;
+    getContentBounds(): Rect | null;
+    getSelectionBounds(): Rect | null;
+    getInstanceBounds(instanceId: string): Rect | null;
     panBy(dx: number, dy: number): void;
     panTo(panX: number, panY: number): void;
     zoomTo(scale: number, options?: {
@@ -740,7 +792,7 @@ export declare interface CanvasHandle {
     resetViewport(): void;
     fitToContent(options?: FitOptions): void;
     fitToSelection(options?: FitOptions): void;
-    scrollToRect(rect: Rect_2, options?: FitOptions): void;
+    scrollToRect(rect: Rect, options?: FitOptions): void;
     readonly toolMode: ComputedRef<CanvasToolMode>;
     getToolMode(): CanvasToolMode;
     setToolMode(mode: CanvasToolMode): void;
@@ -796,6 +848,7 @@ export declare interface CanvasHandle {
         status: DataSourceStatus;
     } | undefined;
     attachBindingDelegate(delegate: WirePageBindingsHandle | null, dataStore?: DataSourceStore | null): void;
+    readonly freeSplit: FreeSplitHandleApi;
 }
 
 export declare interface CanvasHandleOptions {
@@ -834,7 +887,7 @@ export declare interface CanvasLayoutConfig {
     canvas: CanvasViewportConfig;
     background?: CanvasBackgroundConfig;
     behavior?: CanvasBehaviorConfig;
-    rootLayout?: ContainerLayoutConfig;
+    rootLayout?: RootContainerLayoutConfig;
     guides?: {
         grid?: CanvasGridConfig;
         ruler?: CanvasRulerConfig;
@@ -850,6 +903,11 @@ export declare interface CanvasRulerConfig {
     size?: number;
 }
 
+export declare type CanvasSelection = {
+    kind: 'instance';
+    instanceId: string;
+} | FreeSplitSelection;
+
 export declare type CanvasSelectionAction = {
     type: 'select';
     payload: {
@@ -1012,15 +1070,21 @@ export declare type ComponentVersionKey = string;
 
 export declare type ComponentVersionStatus = 'ok' | 'unavailable' | 'missing' | 'broken';
 
-export declare function computeContentBounds(instances: readonly PageInstance[]): Rect_2 | null;
+export declare function computeContentBounds(instances: readonly PageInstance[]): Rect | null;
 
 export declare function computeEffectiveSplitRatios(rawRatios: readonly number[] | undefined, childrenRatios: readonly (number | undefined)[]): number[];
 
-export declare function computeFit(rect: Rect_2, container: {
+export declare function computeFit(rect: Rect, container: {
     w: number;
     h: number;
 }, options?: FitOptions): FitResult;
 
+export declare function computeFreeSplitDividers(root: SplitNode, getLeafRect: (leafId: string) => Rect | null, opts?: {
+    thickness?: number;
+}): FreeSplitDivider[];
+
+export declare function computeFreeSplitNodeRect(node: SplitNode, getLeafRect: (leafId: string) => Rect | null): Rect | null;
+
 export declare function computeInverse(action: CanvasAction, ctx: CanvasContext): CanvasAction[] | null;
 
 export declare function computeNextAxisSize(startAxis: InstanceSizeAxis | undefined, newPxCanvas: number, outletPxCanvas: number | null): InstanceSizeAxis;
@@ -1032,7 +1096,7 @@ export declare function computeNextLayoutBoxAxis(startMode: LayoutBoxAxisMode |
 
 export declare function computeParentLayoutMode(layout: CanvasLayoutConfig | undefined | null, instances: readonly PageInstance[], instanceId: string): ContainerLayoutConfig['mode'] | undefined;
 
-export declare function computeSelectionBounds(instances: readonly PageInstance[], selectedIds: readonly string[]): Rect_2 | null;
+export declare function computeSelectionBounds(instances: readonly PageInstance[], selectedIds: readonly string[]): Rect | null;
 
 export declare function computeSlotChildCanvasRect(instanceId: string, stageEl: HTMLElement | null, viewport: CanvasContext['viewport']): Rect | null;
 
@@ -1040,6 +1104,8 @@ export declare function computeSnap(input: SnapInput): SnapResult;
 
 export declare function computeSplitDividers(parentRect: Rect, ratios: readonly number[], direction: 'horizontal' | 'vertical', gap?: number): SplitDivider[];
 
+export declare function computeSplitShare(leafRect: Rect, edge: Edge, pt: Point): number;
+
 export declare function computeVisibleBounds(viewport: {
     scale: number;
     panX: number;
@@ -1047,13 +1113,13 @@ export declare function computeVisibleBounds(viewport: {
 }, container: {
     w: number;
     h: number;
-}): Rect_2;
+}): Rect;
 
 export declare type ContainerLayoutConfig = {
     mode: 'none';
-} | FreeContainerLayout | FlexContainerLayout | SplitContainerLayout | GridContainerLayout;
+} | FreeContainerLayout | FlexContainerLayout | SplitContainerLayout | GridContainerLayout | FreeSplitContainerLayout;
 
-export declare type ContainerLayoutMode = 'none' | 'free' | 'flex' | 'split' | 'grid';
+export declare type ContainerLayoutMode = 'none' | 'free' | 'flex' | 'split' | 'grid' | 'free-split';
 
 export declare function containerLayoutToCss(cfg: ContainerLayoutConfig | undefined): Record<string, string> | null;
 
@@ -1080,12 +1146,14 @@ export declare function createDocumentStore(initial?: PageDocumentInput): Docume
 
 export declare function createFreePageDocument(opts?: Omit<CreatePageDocumentOptions, 'rootLayout'>): PageDocument;
 
+export declare function createFreeSplitInteraction(ctx: CanvasContext): FreeSplitInteraction;
+
 export declare function createMinimalPageDocument(opts?: CreatePageDocumentOptions): PageDocument;
 
 export declare interface CreatePageDocumentOptions {
     canvasWidth?: number;
     canvasHeight?: number;
-    rootLayout?: ContainerLayoutMode | ContainerLayoutConfig;
+    rootLayout?: RootContainerLayoutMode | RootContainerLayoutConfig;
     instances?: PageInstance[];
     bindings?: NormalizedPageBinding[];
 }
@@ -1275,6 +1343,8 @@ export declare interface DuplicateInstanceOptions {
     };
 }
 
+declare type Edge = 'left' | 'right' | 'top' | 'bottom';
+
 export declare const EFFECTIVE_DEFAULT_SLOT = "default";
 
 export declare function effectiveSlot(inst: PageInstance): string;
@@ -1324,6 +1394,145 @@ export declare interface FreeContainerLayout {
     mode: 'free';
 }
 
+export declare interface FreeSplitContainerLayout {
+    mode: 'free-split';
+    root: SplitNode;
+    structureLocked?: boolean;
+    gap?: number;
+}
+
+export declare interface FreeSplitDivider {
+    nodeId: string;
+    dividerIndex: number;
+    rect: Rect;
+    direction: 'horizontal' | 'vertical';
+}
+
+export declare interface FreeSplitDropTarget {
+    containerId: string;
+    leafId: string;
+    leafEl: HTMLElement;
+}
+
+declare type FreeSplitEdge = 'left' | 'right' | 'top' | 'bottom';
+
+declare interface FreeSplitHandleApi {
+    fill(containerId: string, leafId: string, instance: PageInstance): void;
+    clear(containerId: string, leafId: string): void;
+    swap(containerId: string, leafIdA: string, leafIdB: string): void;
+    resize(containerId: string, nodeId: string, sizes: NodeSize[]): void;
+    split(containerId: string, leafId: string, edge: FreeSplitEdge, newLeafShare: number): {
+        leafId: string;
+        nodeId: string;
+    };
+    merge(containerId: string, leafId: string): void;
+}
+
+export declare interface FreeSplitInteraction {
+    resizeDrag: Readonly<FreeSplitResizeDragState>;
+    isResizing: Readonly<Ref<boolean>>;
+    handleResizeStart(args: FreeSplitResizeStartArgs): {
+        startTracking: boolean;
+    };
+    handleResizeMove(canvasPt: Point): void;
+    handleResizeEnd(): void;
+    cancelResize(): void;
+    requestSplit(containerId: string, leafId: string, edge: Edge, newLeafShare: number): {
+        leafId: string;
+        nodeId: string;
+    } | null;
+    requestMerge(containerId: string, leafId: string): void;
+    requestDelete(containerId: string, leafId: string): void;
+    requestSwap(containerId: string, leafIdA: string, leafIdB: string): void;
+}
+
+declare type FreeSplitMutateAction = {
+    type: 'freeSplitFill';
+    payload: {
+        containerId: string;
+        leafId: string;
+        instance: PageInstance;
+    };
+} | {
+    type: 'freeSplitClear';
+    payload: {
+        containerId: string;
+        leafId: string;
+    };
+} | {
+    type: 'freeSplitSwap';
+    payload: {
+        containerId: string;
+        leafIdA: string;
+        leafIdB: string;
+    };
+} | {
+    type: 'freeSplitResize';
+    payload: {
+        containerId: string;
+        nodeId: string;
+        sizes: NodeSize[];
+    };
+} | {
+    type: 'freeSplitSplit';
+    payload: {
+        containerId: string;
+        leafId: string;
+        edge: 'left' | 'right' | 'top' | 'bottom';
+        newLeafShare: number;
+        newLeafId: string;
+        newNodeId: string;
+    };
+} | {
+    type: 'freeSplitMerge';
+    payload: {
+        containerId: string;
+        leafId: string;
+    };
+};
+
+export declare interface FreeSplitResizeDragState {
+    status: 'idle' | 'active';
+    containerId: string | null;
+    nodeId: string | null;
+    dividerIndex: number | null;
+    startSizes: NodeSize[] | null;
+    branchAxisPx: number;
+    startPt: Point | null;
+    direction: 'horizontal' | 'vertical' | null;
+    snap: boolean;
+}
+
+export declare interface FreeSplitResizeOpts {
+    snap?: boolean;
+    snapFractions?: number[];
+    snapThreshold?: number;
+    minRatioFraction?: number;
+    minPx?: number;
+}
+
+export declare interface FreeSplitResizeStartArgs {
+    containerId: string;
+    nodeId: string;
+    dividerIndex: number;
+    startSizes: NodeSize[];
+    branchAxisPx: number;
+    direction: 'horizontal' | 'vertical';
+    canvasPt: Point;
+    snap?: boolean;
+}
+
+export declare type FreeSplitSelection = {
+    kind: 'freeSplitLeaf';
+    containerId: string;
+    leafId: string;
+} | {
+    kind: 'freeSplitDivider';
+    containerId: string;
+    nodeId: string;
+    dividerIndex: number;
+};
+
 export declare function getBindingInstanceRefs(binding: NormalizedPageBinding): BindingInstanceRef[];
 
 export declare function getDefaultShortcuts(): CanvasShortcutBinding[];
@@ -1432,6 +1641,8 @@ export declare function isEditingText(target: EventTarget | null): boolean;
 
 export declare function isFreePositionLayoutMode(mode: ContainerLayoutConfig['mode'] | undefined): boolean;
 
+export declare function isFreeSplitEnabled(): boolean;
+
 export declare function isInstanceEffectivelyLocked(inst: LockedSubset): boolean;
 
 export declare function isInstancePositionLocked(inst: LockedSubset): boolean;
@@ -1460,7 +1671,7 @@ export declare interface LayoutIssue {
     detail: string;
 }
 
-export declare type LayoutIssueKind = 'cycle' | 'missing-parent' | 'cross-page-parent' | 'orphan-slot' | 'invalid-slot' | 'parent-not-layout' | 'slot-not-allowed-component' | 'slot-multiple-violated' | 'absolute-child-rejected' | 'depth-exceeded';
+export declare type LayoutIssueKind = 'cycle' | 'missing-parent' | 'cross-page-parent' | 'orphan-slot' | 'invalid-slot' | 'parent-not-layout' | 'slot-not-allowed-component' | 'slot-multiple-violated' | 'absolute-child-rejected' | 'depth-exceeded' | 'free-split-duplicate-id' | 'free-split-duplicate-instance' | 'free-split-depth-exceeded' | 'free-split-invalid-size';
 
 export declare interface LayoutItem {
     order?: number;
@@ -1519,6 +1730,8 @@ export declare function matchBinding(binding: CanvasShortcutBinding, ev: Keyboar
 
 export declare const MAX_INSTANCE_TREE_DEPTH = 8;
 
+export declare const MAX_SPLIT_TREE_DEPTH = 8;
+
 declare interface MeasuredStageSize {
     w: number;
     h: number;
@@ -1564,6 +1777,13 @@ export declare interface ModifierKeys {
 
 export declare type MountState = 'idle' | 'pending' | 'mounting' | 'mounted' | 'disposing';
 
+export declare interface NodeSize {
+    mode: 'ratio' | 'px';
+    value: number;
+    min?: number;
+    max?: number;
+}
+
 export declare function normalizeComponentOverrides(raw: PageDocument['componentOverrides'], instances: readonly PageInstance[]): Record<string, PageComponentOverride>;
 
 export declare type NormalizedPageBinding = (PageBindingBase & {
@@ -1574,6 +1794,10 @@ export declare type NormalizedPageBinding = (PageBindingBase & {
     type: 'data';
 });
 
+export declare function normalizeFreeSplitContainersInDocument(instances: PageInstance[]): PageInstance[];
+
+export declare function normalizeFreeSplitTreeShape(node: unknown): SplitNode;
+
 export declare function normalizeGridCells0Based(cells: NonNullable<GridContainerLayout['cells']>): NonNullable<GridContainerLayout['cells']>;
 
 export declare function normalizeInstanceSlotFields(inst: PageInstance): PageInstance;
@@ -1771,13 +1995,6 @@ export declare interface Rect {
     h: number;
 }
 
-declare interface Rect_2 {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-}
-
 export declare function registerDesignerHandle(canvasId: string, handle: CanvasHandle): void;
 
 export declare function registerRendererDiagnostics(canvasId: string, handle: RendererDiagnosticsHandle): void;
@@ -1786,6 +2003,11 @@ declare type RegistryEvent = 'register' | 'unregister';
 
 declare type RegistryListener = (event: RegistryEvent, canvasId: string) => void;
 
+export declare interface RemoveImpact {
+    instanceIds: string[];
+    descendantCount: number;
+}
+
 export declare interface RendererDiagnosticsHandle {
     readonly canvasId: string;
     getSchedulerStats(): {
@@ -1857,8 +2079,20 @@ export declare interface ResizeState {
 
 export declare function resolveCanvasSizePx(size: CanvasSizeValue, fallback?: number): number;
 
+export declare function resolveFreeSplitMergeTarget(root: SplitNode, nodeId: string, dividerIndex: number): string | null;
+
 export declare function resolveMeasuredCanvasSizePx(size: CanvasSizeValue, axisSize: number, fallback?: number): number;
 
+export declare function resolveSplitEdge(leafRect: Rect, pt: Point, opts?: {
+    edgeZonePx?: number;
+}): {
+    edge: Edge;
+} | null;
+
+export declare type RootContainerLayoutConfig = Exclude<ContainerLayoutConfig, FreeSplitContainerLayout>;
+
+export declare type RootContainerLayoutMode = Exclude<ContainerLayoutMode, 'free-split'>;
+
 export declare interface RuntimeInstanceSnapshot {
     instanceId: string;
     componentId: string;
@@ -1875,6 +2109,7 @@ export declare interface SelectionStore {
     readonly selectedIds: ComputedRef<string[]>;
     readonly size: ComputedRef<number>;
     readonly primaryId: ComputedRef<string | undefined>;
+    readonly freeSplitSelection: ComputedRef<FreeSplitSelection | null>;
     select(instanceId: string): void;
     toggleSelect(instanceId: string): void;
     addToSelection(instanceId: string): void;
@@ -1883,6 +2118,9 @@ export declare interface SelectionStore {
     selectAll(instanceIds: string[]): void;
     purgeOrphans(validIds: string[]): void;
     isSelected(instanceId: string): boolean;
+    selectFreeSplitLeaf(containerId: string, leafId: string): void;
+    selectFreeSplitDivider(containerId: string, nodeId: string, dividerIndex: number): void;
+    clearFreeSplitSelection(): void;
 }
 
 export declare const SLOT_CHILD_RESIZE_HANDLES: readonly ["e", "s", "se"];
@@ -1934,6 +2172,14 @@ export declare interface Source {
     css: string;
 }
 
+export declare interface SplitBranch {
+    type: 'split';
+    nodeId: string;
+    dir: 'row' | 'col';
+    children: SplitNode[];
+    sizes: NodeSize[];
+}
+
 export declare interface SplitContainerLayout {
     mode: 'split';
     direction: 'horizontal' | 'vertical';
@@ -1979,6 +2225,15 @@ export declare interface SplitDividerInteraction {
     cancelSplitDividerDrag(): void;
 }
 
+export declare interface SplitLeaf {
+    type: 'leaf';
+    leafId: string;
+    instanceId: string | null;
+    locked?: boolean;
+}
+
+export declare type SplitNode = SplitBranch | SplitLeaf;
+
 export declare interface StaleComponentOverride {
     instanceId: string;
     baseVersionKey: ComponentVersionKey;
@@ -2011,7 +2266,7 @@ export declare interface TreeMoveTarget {
     index?: number;
 }
 
-export declare function unionRects(rects: readonly Rect_2[]): Rect_2 | null;
+export declare function unionRects(rects: readonly Rect[]): Rect | null;
 
 export declare function unregisterDesignerHandle(canvasId: string): void;