@arkcit/engine 0.3.0

package/dist/runtime/index.d.ts

@@ -0,0 +1 @@
+export { UIActionRef, UIRuntime, UIRuntimeAdapter } from '@arkcit/engine-runtime';

package/dist/schema/index.d.ts

@@ -0,0 +1 @@
+export { UIExprValue, UII18nValue, UINode, UINodeEventName, UINodeLayout, UINodeProps, UIRefValue, UIRenderBindingMeta, UISchema, UISchemaNodeMeta, UIValue } from '@arkcit/engine-schema';

package/dist/studio-bridge/index.d.ts

@@ -0,0 +1,501 @@
+import { UINode } from '@arkcit/engine-schema';
+import { UIRuntime, UIActionRef } from '@arkcit/engine-runtime';
+import React__default, { CSSProperties, MouseEvent, ReactNode } from 'react';
+import { U as UIInlineEditorMode, a as UIInlineEditorState, b as UIInlineTextEditorProps } from '../types-CyAE6ZLH.js';
+export { InlineTextEditor, StudioNodeWrapper } from '../components/index.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { UIEngineProps, UINodeWrapperProps } from '@arkcit/engine-core';
+export { UINodeWrapperProps } from '@arkcit/engine-core';
+export { configurePreviewAccordion, configurePreviewExpandablePanel, configurePreviewFormWizard, configurePreviewTabs, materializePreviewForm } from '../preview/index.js';
+import { R as ResolvedStudioWizardStep } from '../wizardEditingHandlers-D50tR-6n.js';
+export { o as ResolvedStudioAccordionState, q as ResolvedStudioFormStructure, s as ResolvedStudioWizardStructure, a as attachStudioWizardEditingHandlers, c as createStudioWizardOnStepChange, n as normalizeStudioTabsProps, p as patchStudioFormFieldNode, b as patchStudioWizardFieldNode, r as resolveStudioAccordionState, d as resolveStudioExpandablePanelState, e as resolveStudioFormNextValues, f as resolveStudioFormResetValues, g as resolveStudioFormStructure, h as resolveStudioTabsContent, i as resolveStudioTabsProps, j as resolveStudioWizardActiveStepFields, k as resolveStudioWizardNextErrors, l as resolveStudioWizardNextValues, m as resolveStudioWizardStructure } from '../wizardEditingHandlers-D50tR-6n.js';
+import '@arkcit/engine-react';
+import '../types-9TZ2lQDP.js';
+
+declare const shouldForceStudioNodeFullWidth: ({ widthPct, nodeType, isStudioRendererContext, colSpan, }: {
+    widthPct: number | null;
+    nodeType: string;
+    isStudioRendererContext: boolean;
+    colSpan?: number;
+}) => boolean;
+
+type InlineTextMode = "primitive" | "json" | "translation";
+type InlineTextEntry = {
+    value: string;
+    mode: InlineTextMode;
+};
+type GetEditableTextValueArgs = {
+    node: UINode;
+    nodeProps: Record<string, unknown>;
+    propName: string;
+    runtime: UIRuntime;
+    resolveTranslationValue: (value: unknown, runtime: UIRuntime) => unknown;
+};
+declare const getEditableTextValue: ({ node, nodeProps, propName, runtime, resolveTranslationValue, }: GetEditableTextValueArgs) => InlineTextEntry | null;
+type SelectCandidateInlinePropArgs = {
+    node: UINode;
+    isWizardStepNode: boolean;
+    orderedEditableTextProps: string[];
+    getTextValue: (propName: string) => InlineTextEntry | null;
+};
+declare const selectCandidateInlineProp: ({ node, isWizardStepNode, orderedEditableTextProps, getTextValue, }: SelectCandidateInlinePropArgs) => string | null;
+type SelectEffectiveInlinePropArgs = {
+    node: UINode;
+    isWizardStepNode: boolean;
+    hasRenderableChildren: boolean;
+    childrenInlineEntry: InlineTextEntry | null;
+    candidateInlineProp: string | null;
+};
+declare const selectEffectiveInlineProp: ({ node, isWizardStepNode, hasRenderableChildren, childrenInlineEntry, candidateInlineProp, }: SelectEffectiveInlinePropArgs) => string | null;
+
+declare const computeInlineEditorStyle: ({ wrapperElement, targetElementForEditor, }: {
+    wrapperElement: HTMLElement;
+    targetElementForEditor: HTMLElement | null;
+}) => CSSProperties;
+declare const shouldUseMultilineInlineEditor: ({ mode, value, }: {
+    mode: UIInlineEditorMode;
+    value: string;
+}) => boolean;
+declare const applyInlineEditingValue: ({ editingState, rawValue, schemaNodes, onInlineTextEdit, findNodeById, }: {
+    editingState: {
+        nodeId: string;
+        propName: string;
+        mode: UIInlineEditorMode;
+    };
+    rawValue: string;
+    schemaNodes: UINode[];
+    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+    findNodeById: (nodeId: string, nodes: UINode[]) => UINode | null;
+}) => void;
+
+type InlineEntry = {
+    value: string;
+    mode: UIInlineEditorState["mode"];
+};
+declare const openInlineEditorFromDoubleClick: ({ event, nodeId, nodeType, effectiveCandidateInlineProp, getTextValue, setInlineEditing, }: {
+    event: MouseEvent<HTMLDivElement>;
+    nodeId: string;
+    nodeType: string;
+    effectiveCandidateInlineProp: string | null;
+    getTextValue: (propName: string) => InlineEntry | null;
+    setInlineEditing: (state: UIInlineEditorState) => void;
+}) => boolean;
+
+type ResolveInlineEditingTargetArgs = {
+    node: UINode;
+    nodeProps: Record<string, unknown>;
+    runtime: UIRuntime;
+    editableTextProps: string[];
+    resolveTranslationValue: (value: unknown, runtime: UIRuntime) => unknown;
+};
+type InlineEditingTargetResolution = {
+    canResolveInlineText: boolean;
+    isWizardStepNode: boolean;
+    orderedEditableTextProps: string[];
+    getTextValue: (propName: string) => InlineTextEntry | null;
+    effectiveCandidateInlineProp: string | null;
+};
+declare const resolveInlineEditingTarget: ({ node, nodeProps, runtime, editableTextProps, resolveTranslationValue, }: ResolveInlineEditingTargetArgs) => InlineEditingTargetResolution;
+
+type UIResizeState = {
+    nodeId: string;
+    startX: number;
+    startY: number;
+    startWidthPct: number;
+    startHeightPct: number;
+    startHeightPx: number;
+    containerWidth: number;
+    containerHeight: number;
+    lastSize?: {
+        widthPct: number;
+        heightPct: number;
+        heightPx?: number;
+    };
+};
+type UIPinchResizeState = {
+    nodeId: string;
+    startDistance: number;
+    startWidthPct: number;
+    startHeightPct: number;
+    lastSize?: {
+        widthPct: number;
+        heightPct: number;
+        heightPx?: number;
+    };
+};
+declare const computeMouseResizeSize: ({ state, clientX, clientY, minWidthPct, minHeightPct, minHeightPx, }: {
+    state: UIResizeState;
+    clientX: number;
+    clientY: number;
+    minWidthPct: number;
+    minHeightPct: number;
+    minHeightPx: number;
+}) => {
+    widthPct: number;
+    heightPct: number;
+    heightPx: number;
+};
+declare const computePinchResizeSize: ({ state, distance, minWidthPct, minHeightPct, }: {
+    state: UIPinchResizeState;
+    distance: number;
+    minWidthPct: number;
+    minHeightPct: number;
+}) => {
+    widthPct: number;
+    heightPct: number;
+} | null;
+declare const createMouseResizeState: ({ nodeId, clientX, clientY, widthPct, heightPct, heightPx, elementRect, parentRect, minHeightPx, }: {
+    nodeId: string;
+    clientX: number;
+    clientY: number;
+    widthPct: number | null;
+    heightPct: number | null;
+    heightPx: number | null;
+    elementRect: DOMRect;
+    parentRect: DOMRect;
+    minHeightPx: number;
+}) => UIResizeState;
+declare const createPinchResizeState: ({ nodeId, widthPct, heightPct, distance, }: {
+    nodeId: string;
+    widthPct: number | null;
+    heightPct: number | null;
+    distance: number;
+}) => UIPinchResizeState;
+
+type TouchHandlerParams = {
+    node: UINode;
+    widthPct: number | null;
+    heightPct: number | null;
+    onNodeResize?: (nodeId: string, size: {
+        widthPct: number;
+        heightPct: number;
+        heightPx?: number;
+    }) => void;
+    onNodeResizeStart?: (nodeId: string) => void;
+    onNodeResizeEnd?: (nodeId: string, size: {
+        widthPct: number;
+        heightPct: number;
+        heightPx?: number;
+    }) => void;
+    pinchStateRef: React.MutableRefObject<UIPinchResizeState | null>;
+    minWidthPct: number;
+    minHeightPct: number;
+};
+declare const createTouchResizeHandlers: ({ node, widthPct, heightPct, onNodeResize, onNodeResizeStart, onNodeResizeEnd, pinchStateRef, minWidthPct, minHeightPct, }: TouchHandlerParams) => {
+    onTouchStart: (event: React.TouchEvent<HTMLDivElement>) => void;
+    onTouchMove: (event: React.TouchEvent<HTMLDivElement>) => void;
+    onTouchEnd: () => void;
+};
+type MouseResizeParams = {
+    node: UINode;
+    widthPct: number | null;
+    heightPct: number | null;
+    heightPx: number | null;
+    onNodeResize?: (nodeId: string, size: {
+        widthPct: number;
+        heightPct: number;
+        heightPx?: number;
+    }) => void;
+    onNodeResizeStart?: (nodeId: string) => void;
+    resizeStateRef: React.MutableRefObject<UIResizeState | null>;
+    minHeightPx: number;
+};
+declare const createMouseResizeHandler: ({ node, widthPct, heightPct, heightPx, onNodeResize, onNodeResizeStart, resizeStateRef, minHeightPx, }: MouseResizeParams) => ((event: React.MouseEvent<HTMLButtonElement>) => void) | undefined;
+type ClickHandlerParams = {
+    node: UINode;
+    nodeProps: Record<string, unknown>;
+    schemaNodes: UINode[];
+    runtime: UIRuntime;
+    onNodeClick?: (nodeId: string) => void;
+    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+    isInlineEditingNode: boolean;
+    enableEventOnClick: boolean;
+    isFormInteractiveTarget: (target: HTMLElement | null) => boolean;
+};
+declare const createStudioNodeClickHandler: ({ node, nodeProps, schemaNodes, runtime, onNodeClick, onInlineTextEdit, isInlineEditingNode, enableEventOnClick, isFormInteractiveTarget, }: ClickHandlerParams) => (event: React.MouseEvent<HTMLDivElement>) => void;
+type DoubleClickHandlerParams = {
+    node: UINode;
+    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+    effectiveCandidateInlineProp: string | null;
+    getTextValue: (propName: string) => InlineTextEntry | null;
+    setInlineEditing: (state: UIInlineEditorState | null) => void;
+};
+declare const createStudioNodeDoubleClickHandler: ({ node, onInlineTextEdit, effectiveCandidateInlineProp, getTextValue, setInlineEditing, }: DoubleClickHandlerParams) => (event: React.MouseEvent<HTMLDivElement>) => void;
+
+type WrapperStyleParams = {
+    isOpenStudioOverlayNode: boolean;
+    wrapperClassName: string;
+    widthPct: number | null;
+    shouldForceFullWidth: boolean;
+};
+declare const getNodeWrapperPresentation: ({ isOpenStudioOverlayNode, wrapperClassName, widthPct, shouldForceFullWidth, }: WrapperStyleParams) => {
+    wrapperStyle: {
+        position: "absolute";
+        inset: number;
+        width: string;
+        height: string;
+    } | {
+        width: string;
+        position?: undefined;
+        inset?: undefined;
+        height?: undefined;
+    } | undefined;
+    overlayWrapperClassName: string;
+    requiresPlainWrapper: boolean;
+};
+type InteractionStateParams = {
+    node: UINode;
+    selectedNodeId: string | null;
+    effectiveCandidateInlineProp: string | null;
+    isInlineEditingNode: boolean;
+    isOpenStudioOverlayNode: boolean;
+    isInsideForm: boolean;
+    isInsideFormWizard: boolean;
+    isInsideStepForm: boolean;
+    inlinePropName?: string;
+};
+declare const getStudioNodeInteractionState: ({ node, selectedNodeId, effectiveCandidateInlineProp, isInlineEditingNode, isOpenStudioOverlayNode, isInsideForm, isInsideFormWizard, isInsideStepForm, inlinePropName, }: InteractionStateParams) => {
+    isSelected: boolean;
+    allowNodeHandles: boolean;
+    studioFormFieldWrapperClassName: string;
+    cursorClassName: string;
+    preserveContentWhileInlineEditing: boolean;
+};
+declare const renderPlainWrappedNode: ({ nodeId, overlayWrapperClassName, wrapperStyle, nodeContent, }: {
+    nodeId: string;
+    overlayWrapperClassName: string;
+    wrapperStyle: React__default.CSSProperties | undefined;
+    nodeContent: React__default.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
+
+declare const markSuppressStudioClick: (durationMs?: number) => void;
+declare const shouldSuppressStudioClick: () => boolean;
+
+type OverlaySyncParams = {
+    node: UINode;
+    componentProps: Record<string, unknown>;
+    runtime: UIRuntime;
+    overlaysByNodeId: Record<string, unknown>;
+    renderBindingProps: Record<string, unknown>;
+    resolvedChildContent: React__default.ReactNode | null;
+    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+    isStudioRendererContext: boolean;
+    dropdownOpenByNodeId: Record<string, boolean>;
+    setDropdownOpenByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, boolean>>>;
+};
+declare const readOverlayState: (runtime: UIRuntime) => Record<string, unknown>;
+declare const applyStudioOverlayComponentProps: ({ node, componentProps, runtime, overlaysByNodeId, renderBindingProps, resolvedChildContent, onInlineTextEdit, isStudioRendererContext, dropdownOpenByNodeId, setDropdownOpenByNodeId, }: OverlaySyncParams) => void;
+declare const getOpenStudioOverlayState: ({ node, nodeProps, overlaysByNodeId, }: {
+    node: UINode;
+    nodeProps: Record<string, unknown>;
+    overlaysByNodeId: Record<string, unknown>;
+}) => boolean;
+
+type RenderNodeFrameParams = {
+    node: UINode;
+    nodeProps: Record<string, unknown>;
+    nodeContent: React__default.ReactNode;
+    selectedNodeId: string | null;
+    onNodeClick?: (nodeId: string) => void;
+    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+    onNodeResize?: (nodeId: string, size: {
+        widthPct: number;
+        heightPct: number;
+        heightPx?: number;
+    }) => void;
+    onNodeResizeStart?: (nodeId: string) => void;
+    onNodeResizeEnd?: (nodeId: string, size: {
+        widthPct: number;
+        heightPct: number;
+        heightPx?: number;
+    }) => void;
+    widthPct: number | null;
+    heightPct: number | null;
+    heightPx: number | null;
+    wrapperClassName: string;
+    isOpenStudioOverlayNode: boolean;
+    shouldForceFullWidth: boolean;
+    effectiveCandidateInlineProp: string | null;
+    inlineEditing: UIInlineEditorState | null;
+    isInlineEditingNode: boolean;
+    ancestorTypeMembership: Record<string, Set<string>>;
+    schemaNodes: UINode[];
+    runtime: UIRuntime;
+    enableEventOnClick: boolean;
+    isFormInteractiveTarget: (target: HTMLElement | null) => boolean;
+    getTextValue: (propName: string) => {
+        value: string;
+        mode: UIInlineEditorState["mode"];
+    } | null;
+    setInlineEditing: React__default.Dispatch<React__default.SetStateAction<UIInlineEditorState | null>>;
+    inlineEditor: React__default.ReactNode;
+    NodeWrapper: React__default.ComponentType<{
+        nodeId: string;
+        wrapperClassName?: string;
+        cursorClassName?: string;
+        isSelected: boolean;
+        allowDragHandle?: boolean;
+        allowResizeHandle?: boolean;
+        style?: React__default.CSSProperties;
+        onClick?: (event: React__default.MouseEvent<HTMLDivElement>) => void;
+        onDoubleClick?: (event: React__default.MouseEvent<HTMLDivElement>) => void;
+        onTouchStart?: (event: React__default.TouchEvent<HTMLDivElement>) => void;
+        onTouchMove?: (event: React__default.TouchEvent<HTMLDivElement>) => void;
+        onTouchEnd?: (event: React__default.TouchEvent<HTMLDivElement>) => void;
+        showResizeHandle: boolean;
+        onResizeMouseDown?: (event: React__default.MouseEvent<HTMLButtonElement>) => void;
+        isInlineEditing: boolean;
+        preserveContentWhileInlineEditing?: boolean;
+        children: React__default.ReactNode;
+        inlineEditor?: React__default.ReactNode;
+    }>;
+    overlaysByNodeId: Record<string, unknown>;
+    getOpenStudioOverlayState: (args: {
+        node: UINode;
+        nodeProps: Record<string, unknown>;
+        overlaysByNodeId: Record<string, unknown>;
+    }) => boolean;
+    resizeStateRef: React__default.MutableRefObject<{
+        nodeId: string;
+        startX: number;
+        startY: number;
+        startWidthPct: number;
+        startHeightPct: number;
+        startHeightPx: number;
+        containerWidth: number;
+        containerHeight: number;
+        lastSize?: {
+            widthPct: number;
+            heightPct: number;
+            heightPx?: number;
+        };
+    } | null>;
+    pinchStateRef: React__default.MutableRefObject<{
+        nodeId: string;
+        startDistance: number;
+        startWidthPct: number;
+        startHeightPct: number;
+        lastSize?: {
+            widthPct: number;
+            heightPct: number;
+            heightPx?: number;
+        };
+    } | null>;
+    minWidthPct: number;
+    minHeightPct: number;
+    minHeightPx: number;
+    overlayRootId: string;
+};
+declare const renderNodeFrame: ({ node, nodeProps, nodeContent, selectedNodeId, onNodeClick, onInlineTextEdit, onNodeResize, onNodeResizeStart, onNodeResizeEnd, widthPct, heightPct, heightPx, wrapperClassName, isOpenStudioOverlayNode, shouldForceFullWidth, effectiveCandidateInlineProp, inlineEditing, isInlineEditingNode, ancestorTypeMembership, schemaNodes, runtime, enableEventOnClick, isFormInteractiveTarget, getTextValue, setInlineEditing, inlineEditor, NodeWrapper, overlaysByNodeId, getOpenStudioOverlayState, resizeStateRef, pinchStateRef, minWidthPct, minHeightPct, minHeightPx, overlayRootId, }: RenderNodeFrameParams) => string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+
+type RenderSafeNodeArgs = {
+    node: UINode;
+    registry: NonNullable<UIEngineProps["registry"]>;
+    runtime: UIRuntime;
+    schemaNodes: UINode[];
+    renderNode: (node: UINode, studioSizing?: {
+        widthPct: number | null;
+        heightPct: number | null;
+        heightPx: number | null;
+    }) => React__default.ReactNode;
+    isStudioRendererContext: boolean;
+    overlaysByNodeId: Record<string, unknown>;
+    selectedNodeId: string | null;
+    onNodeClick: UIEngineProps["onNodeClick"];
+    onInlineTextEdit: UIEngineProps["onInlineTextEdit"];
+    onNodeResize: UIEngineProps["onNodeResize"];
+    onNodeResizeStart: UIEngineProps["onNodeResizeStart"];
+    onNodeResizeEnd: UIEngineProps["onNodeResizeEnd"];
+    inlineEditing: UIInlineEditorState | null;
+    setInlineEditing: React__default.Dispatch<React__default.SetStateAction<UIInlineEditorState | null>>;
+    ancestorTypeMembership: Record<string, Set<string>>;
+    resizeStateRef: React__default.MutableRefObject<{
+        nodeId: string;
+        startX: number;
+        startY: number;
+        startWidthPct: number;
+        startHeightPct: number;
+        startHeightPx: number;
+        containerWidth: number;
+        containerHeight: number;
+        lastSize?: {
+            widthPct: number;
+            heightPct: number;
+            heightPx?: number;
+        };
+    } | null>;
+    pinchStateRef: React__default.MutableRefObject<{
+        nodeId: string;
+        startDistance: number;
+        startWidthPct: number;
+        startHeightPct: number;
+        lastSize?: {
+            widthPct: number;
+            heightPct: number;
+            heightPx?: number;
+        };
+    } | null>;
+    minWidthPct: number;
+    minHeightPct: number;
+    minHeightPx: number;
+    overlayRootId: string;
+    NodeWrapper: React__default.ComponentType<UINodeWrapperProps>;
+    InlineTextEditorComponent: React__default.ComponentType<UIInlineTextEditorProps>;
+    isFormInteractiveTarget: (target: HTMLElement | null) => boolean;
+};
+declare const renderSafeNode: ({ node, registry, runtime, schemaNodes, renderNode, isStudioRendererContext, overlaysByNodeId, selectedNodeId, onNodeClick, onInlineTextEdit, onNodeResize, onNodeResizeStart, onNodeResizeEnd, inlineEditing, setInlineEditing, ancestorTypeMembership, resizeStateRef, pinchStateRef, minWidthPct, minHeightPct, minHeightPx, overlayRootId, NodeWrapper, InlineTextEditorComponent, isFormInteractiveTarget, }: RenderSafeNodeArgs) => string | number | bigint | boolean | Iterable<React__default.ReactNode> | Promise<string | number | bigint | boolean | React__default.ReactPortal | React__default.ReactElement<unknown, string | React__default.JSXElementConstructor<any>> | Iterable<React__default.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+
+type MaterializeStudioWizardStepsArgs = {
+    nodeId: string;
+    currentSteps: ResolvedStudioWizardStep[];
+    existingFormConfig: Record<string, unknown>;
+    rawWizardValues: Record<string, unknown>;
+    stepIdToNode: Record<string, UINode>;
+    runtime: UIRuntime;
+    renderSafeNode: (node: UINode) => ReactNode;
+    captureFieldFocus: (target: EventTarget | null) => void;
+    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+};
+declare const materializeStudioWizardSteps: ({ nodeId, currentSteps, existingFormConfig, rawWizardValues, stepIdToNode, runtime, renderSafeNode, captureFieldFocus, onInlineTextEdit, }: MaterializeStudioWizardStepsArgs) => {
+    id: string;
+    title: unknown;
+    description: unknown;
+    titleNode: React__default.ReactNode;
+    descriptionNode: React__default.ReactNode;
+    isValid: boolean;
+    content: React__default.ReactNode;
+}[];
+
+declare const isInteractiveSelectionTarget: ({ targetElement, nodeType, isFormInteractiveTarget, }: {
+    targetElement: HTMLElement | null;
+    nodeType: string;
+    isFormInteractiveTarget: (target: HTMLElement | null) => boolean;
+}) => boolean;
+declare const resolveButtonOverlayTarget: ({ clickEvent, boundTargetNodeId, overlayCandidates, }: {
+    clickEvent: UIActionRef | undefined;
+    boundTargetNodeId: string;
+    overlayCandidates: string[];
+}) => {
+    actionLabel: string;
+    payload: Record<string, unknown> | null;
+    targetNodeId: string;
+};
+declare const buildNormalizedActionRef: ({ clickEvent, payload, targetNodeId, }: {
+    clickEvent: UIActionRef;
+    payload: Record<string, unknown> | null;
+    targetNodeId: string;
+}) => UIActionRef;
+declare const syncOverlayStateFromAction: ({ targetNodeId, actionLabel, runtime, onInlineTextEdit, findNodeById, schemaNodes, }: {
+    targetNodeId: string;
+    actionLabel: string;
+    runtime: UIRuntime;
+    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+    findNodeById: (nodeId: string, nodes: UINode[]) => UINode | null;
+    schemaNodes: UINode[];
+}) => void;
+declare const resolveClickedNodeId: ({ targetElement, fallbackNodeId, }: {
+    targetElement: HTMLElement | null;
+    fallbackNodeId: string;
+}) => string;
+
+export { type InlineEditingTargetResolution, type InlineTextEntry, type InlineTextMode, ResolvedStudioWizardStep, UIInlineEditorMode as UIInlineEditingMode, UIInlineEditorState as UIInlineEditingState, type UIPinchResizeState, type UIResizeState, applyInlineEditingValue, applyStudioOverlayComponentProps, buildNormalizedActionRef, computeInlineEditorStyle, computeMouseResizeSize, computePinchResizeSize, createMouseResizeHandler, createMouseResizeState, createPinchResizeState, createStudioNodeClickHandler, createStudioNodeDoubleClickHandler, createTouchResizeHandlers, getEditableTextValue, getNodeWrapperPresentation, getOpenStudioOverlayState, getStudioNodeInteractionState, isInteractiveSelectionTarget, markSuppressStudioClick, materializeStudioWizardSteps, openInlineEditorFromDoubleClick, readOverlayState, renderNodeFrame, renderPlainWrappedNode, renderSafeNode, resolveButtonOverlayTarget, resolveClickedNodeId, resolveInlineEditingTarget, selectCandidateInlineProp, selectEffectiveInlineProp, shouldForceStudioNodeFullWidth, shouldSuppressStudioClick, shouldUseMultilineInlineEditor, syncOverlayStateFromAction };