@arkcit/engine-react 0.3.7 → 0.3.8

package/dist/engine.d.ts

@@ -3,8 +3,8 @@ import React__default from 'react';
 import { UIEngineProps, UINodeSize, UINodeWrapperProps } from '@arkcit/engine-core';
 import { UINode } from '@arkcit/engine-schema';
 import { UIRuntimeAdapter } from '@arkcit/engine-runtime';
-import { r as renderReactNode } from './renderReactNode-DmxD8hot.js';
-export { StaticReactWebEngineRoot } from './static-engine.js';
+import { a as RenderReactNodeDependencies } from './renderReactNode-xwA81IXf.js';
+export { StaticReactWebEngineRoot, StaticReactWebEngineRootArgs, StaticReactWebEngineRootDependencies, StaticRenderSafeNodeArgs } from './static-engine.js';
 import '@arkcit/engine-render-layer';
 
 type EngineWarningFallbackProps = {
@@ -30,7 +30,7 @@ declare class NodeErrorBoundary extends React__default.Component<NodeErrorBounda
     render(): 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 UseUIEngineEffectsArgs = {
+type ReactWebUseUIEngineEffectsArgs = {
     schema: UIEngineProps["schema"];
     runtime: UIRuntimeAdapter;
     onNodeResize?: ((nodeId: string, size: UINodeSize) => void) | undefined;
@@ -42,12 +42,12 @@ type UseUIEngineEffectsArgs = {
     minHeightPct: number;
     minHeightPx: number;
 };
-type UseUIEngineEffectsResult = {
+type ReactWebUseUIEngineEffectsResult = {
     ancestorTypeMembership: Record<string, Set<string>>;
     overlaysByNodeId: Record<string, unknown>;
     captureFieldFocus: (target: EventTarget | null) => void;
 };
-type RenderSafeNodeArgs<TInlineEditing> = {
+type ReactWebRenderSafeNodeArgs<TInlineEditing = unknown> = {
     node: UINode;
     registry: NonNullable<UIEngineProps["registry"]>;
     runtime: UIRuntimeAdapter;
@@ -77,9 +77,9 @@ type RenderSafeNodeArgs<TInlineEditing> = {
     NodeWrapper: React__default.ComponentType<UINodeWrapperProps>;
     isFormInteractiveTarget: (target: HTMLElement | null) => boolean;
 };
-type ReactWebEngineRootDependencies<TInlineEditing> = {
-    useUIEngineEffects: (args: UseUIEngineEffectsArgs) => UseUIEngineEffectsResult;
-    renderSafeNode: (args: RenderSafeNodeArgs<TInlineEditing>) => React__default.ReactNode;
+type ReactWebEngineRootDependencies<TInlineEditing = unknown> = {
+    useUIEngineEffects: (args: ReactWebUseUIEngineEffectsArgs) => ReactWebUseUIEngineEffectsResult;
+    renderSafeNode: (args: ReactWebRenderSafeNodeArgs<TInlineEditing>) => React__default.ReactNode;
     InlineTextEditor: React__default.ComponentType<{
         editing: TInlineEditing;
         onChange: (value: string) => void;
@@ -87,11 +87,11 @@ type ReactWebEngineRootDependencies<TInlineEditing> = {
         onCommit: () => void;
     }>;
     StudioNodeWrapper: React__default.ComponentType<UINodeWrapperProps>;
-    renderReactNodeDependencies: Parameters<typeof renderReactNode<TInlineEditing>>[0]["dependencies"];
+    renderReactNodeDependencies: RenderReactNodeDependencies<TInlineEditing>;
 };
-type ReactWebEngineRootArgs<TInlineEditing> = UIEngineProps & {
+type ReactWebEngineRootArgs<TInlineEditing = unknown> = UIEngineProps & {
     dependencies: ReactWebEngineRootDependencies<TInlineEditing>;
 };
 declare const ReactWebEngineRoot: <TInlineEditing = unknown>({ schema, registry, store, onNodeClick, onInlineTextEdit, onNodeResize, onNodeResizeStart, onNodeResizeEnd, onNodeDragStart, onNodeDragOverTarget, onNodeDropTarget, selectedNodeId, nodeWrapper, dependencies, }: ReactWebEngineRootArgs<TInlineEditing>) => react_jsx_runtime.JSX.Element;
 
-export { EngineWarningFallback, NodeErrorBoundary, ReactWebEngineRoot };
+export { EngineWarningFallback, NodeErrorBoundary, ReactWebEngineRoot, type ReactWebEngineRootArgs, type ReactWebEngineRootDependencies, type ReactWebRenderSafeNodeArgs, type ReactWebUseUIEngineEffectsArgs, type ReactWebUseUIEngineEffectsResult };

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 export { applyContentComposition, applyNavigationComposition } from './composition.js';
 export { applyRenderDirectives } from './directives.js';
-export { EngineWarningFallback, NodeErrorBoundary, ReactWebEngineRoot } from './engine.js';
-export { StaticReactWebEngineRoot } from './static-engine.js';
+export { EngineWarningFallback, NodeErrorBoundary, ReactWebEngineRoot, ReactWebEngineRootArgs, ReactWebEngineRootDependencies, ReactWebRenderSafeNodeArgs, ReactWebUseUIEngineEffectsArgs, ReactWebUseUIEngineEffectsResult } from './engine.js';
+export { StaticReactWebEngineRoot, StaticReactWebEngineRootArgs, StaticReactWebEngineRootDependencies, StaticRenderSafeNodeArgs } from './static-engine.js';
 export { useUIEngineEffects, useUIEngineState } from './hooks.js';
 export { buildAccordionItems, buildCoverContent, buildCoverMedia, buildExpandablePanelChildren, buildScrollRevealChildren, materializeAccordionItems, materializeBoundTable, materializeChildContent, materializeCoverContent, materializeExpandablePanelContent, materializeTabsContent } from './materialization.js';
 export { BoundTableColumn, BoundTableRow, ReactNodeRenderPlan, ResolvedBoundTableData, ResolvedReactNode, buildNodeResetToken, configurePreviewLinkBehavior, finalizeRenderedNode, getGridItemWrapperProps, normalizeRenderableChild, prepareRenderableChildren, resolveBoundTableData, resolveReactNodePlan, resolveResolvedReactNode, toBoolean } from './rendering.js';
-export { r as renderReactNode } from './renderReactNode-DmxD8hot.js';
+export { R as RenderReactNodeArgs, a as RenderReactNodeDependencies, r as renderReactNode } from './renderReactNode-xwA81IXf.js';
 export { AccordionItemDescriptor, CoverContentDescriptor, ExpandablePanelContentDescriptor, ResolvedNodeContentDescriptor as ResolvedChildContentDescriptor, ResolvedNodeChildDescriptor as ResolvedChildDescriptor, TabsContentDescriptor } from '@arkcit/engine-render-layer';
 export { ComponentRegistry, ComponentRegistryEntry } from '@arkcit/engine-core';
 import 'react';

package/dist/index.js

@@ -1506,6 +1506,11 @@ var normalizeRenderableChild = (value) => {
       const nestedChildren = candidate.props.children;
       return normalizeRenderableChild(nestedChildren);
     }
+    for (const key of ["children", "label", "title", "content", "text", "value"]) {
+      if (key in candidate) {
+        return normalizeRenderableChild(candidate[key]);
+      }
+    }
   }
   return null;
 };

package/dist/renderReactNode-xwA81IXf.d.ts

@@ -0,0 +1,110 @@
+import React__default from 'react';
+import { ComponentRegistry } from '@arkcit/engine-core';
+import { UINode } from '@arkcit/engine-schema';
+import { UIRuntimeAdapter } from '@arkcit/engine-runtime';
+import { ContentCompositionPlan, RenderDirectivePlan, NavigationCompositionPlan, FinalRenderPlan } from '@arkcit/engine-render-layer';
+
+type RenderReactNodeDependencies<TInlineEditing = unknown> = {
+    applyStudioOverlayComponentProps: (args: {
+        node: UINode;
+        componentProps: Record<string, unknown>;
+        runtime: UIRuntimeAdapter;
+        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>>>;
+    }) => void;
+    applyContentComposition: (args: {
+        node: UINode;
+        componentProps: Record<string, unknown>;
+        isStudioRendererContext: boolean;
+        internalStudioNodeTypes: Set<string>;
+        schemaNodes: UINode[];
+        onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+        captureFieldFocus: (target: EventTarget | null) => void;
+        renderSafeNode: (node: UINode) => React__default.ReactNode;
+        normalizeRenderableChild: (value: unknown) => React__default.ReactNode;
+        findNodeById: (nodeId: string, nodes: UINode[]) => UINode | null;
+        runtime: UIRuntimeAdapter;
+        plans?: ContentCompositionPlan[];
+    }) => React__default.ReactNode | null;
+    applyRenderDirectives: (args: {
+        node: UINode;
+        componentProps: Record<string, unknown>;
+        renderBindingProps: Record<string, unknown>;
+        runtime: UIRuntimeAdapter;
+        plans?: RenderDirectivePlan[];
+    }) => void;
+    applyNavigationComposition: (args: {
+        node: UINode;
+        componentProps: Record<string, unknown>;
+        isStudioRendererContext: boolean;
+        selectedNodeId: string | null;
+        wizardActiveStepByNodeId: Record<string, string>;
+        accordionOpenIdsByNodeId: Record<string, string[]>;
+        expandablePanelOpenByNodeId: Record<string, boolean>;
+        runtime: UIRuntimeAdapter;
+        setWizardActiveStepByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, string>>>;
+        setAccordionOpenIdsByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, string[]>>>;
+        setExpandablePanelOpenByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, boolean>>>;
+        onNodeClick?: (nodeId: string) => void;
+        onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+        renderSafeNode: (node: UINode) => React__default.ReactNode;
+        normalizeRenderableChild: (value: unknown) => React__default.ReactNode;
+        captureFieldFocus: (target: EventTarget | null) => void;
+        setInlineEditing: React__default.Dispatch<React__default.SetStateAction<TInlineEditing | null>>;
+        internalStudioNodeTypes: Set<string>;
+        plans?: NavigationCompositionPlan[];
+    }) => void;
+    finalizeRenderedNode: (args: {
+        node: UINode;
+        children: React__default.ReactNode[] | undefined;
+        componentProps: Record<string, unknown>;
+        registryComponent: React__default.ComponentType<Record<string, unknown>>;
+        runtime: UIRuntimeAdapter;
+        isStudioRendererContext: boolean;
+        studioSizing?: {
+            widthPct: number | null;
+            heightPct: number | null;
+            heightPx: number | null;
+        };
+        plans?: FinalRenderPlan[];
+    }) => React__default.ReactNode | null;
+    normalizeRenderableChild: (value: unknown) => React__default.ReactNode;
+    findNodeById: (nodeId: string, nodes: UINode[]) => UINode | null;
+};
+type RenderReactNodeArgs<TInlineEditing = unknown> = {
+    node: UINode;
+    runtime: UIRuntimeAdapter;
+    registry: ComponentRegistry;
+    schemaNodes: UINode[];
+    renderSafeNode: (node: UINode) => React__default.ReactNode;
+    internalStudioNodeTypes: Set<string>;
+    overlaysByNodeId: Record<string, unknown>;
+    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
+    isStudioRendererContext: boolean;
+    dropdownOpenByNodeId: Record<string, boolean>;
+    setDropdownOpenByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, boolean>>>;
+    captureFieldFocus: (target: EventTarget | null) => void;
+    selectedNodeId: string | null | undefined;
+    wizardActiveStepByNodeId: Record<string, string>;
+    accordionOpenIdsByNodeId: Record<string, string[]>;
+    expandablePanelOpenByNodeId: Record<string, boolean>;
+    setWizardActiveStepByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, string>>>;
+    setAccordionOpenIdsByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, string[]>>>;
+    setExpandablePanelOpenByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, boolean>>>;
+    onNodeClick?: (nodeId: string) => void;
+    setInlineEditing: React__default.Dispatch<React__default.SetStateAction<TInlineEditing | null>>;
+    studioSizing?: {
+        widthPct: number | null;
+        heightPct: number | null;
+        heightPx: number | null;
+    };
+    dependencies: RenderReactNodeDependencies<TInlineEditing>;
+};
+declare const renderReactNode: <TInlineEditing = unknown>({ node, runtime, registry, schemaNodes, renderSafeNode, internalStudioNodeTypes, overlaysByNodeId, onInlineTextEdit, isStudioRendererContext, dropdownOpenByNodeId, setDropdownOpenByNodeId, captureFieldFocus, selectedNodeId, wizardActiveStepByNodeId, accordionOpenIdsByNodeId, expandablePanelOpenByNodeId, setWizardActiveStepByNodeId, setAccordionOpenIdsByNodeId, setExpandablePanelOpenByNodeId, onNodeClick, setInlineEditing, studioSizing, dependencies, }: RenderReactNodeArgs<TInlineEditing>) => React__default.ReactNode;
+
+export { type RenderReactNodeArgs as R, type RenderReactNodeDependencies as a, renderReactNode as r };

package/dist/rendering.d.ts

@@ -3,7 +3,7 @@ import { FinalRenderPlan, ResolvedNodeChildDescriptor, ResolvedNodeContentDescri
 import { UINode } from '@arkcit/engine-schema';
 import { UIRuntimeAdapter } from '@arkcit/engine-runtime';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-export { r as renderReactNode } from './renderReactNode-DmxD8hot.js';
+export { R as RenderReactNodeArgs, a as RenderReactNodeDependencies, r as renderReactNode } from './renderReactNode-xwA81IXf.js';
 import { ComponentRegistry } from '@arkcit/engine-core';
 
 type FinalizeRenderedNodeParams = {

package/dist/rendering.js

@@ -458,6 +458,11 @@ var normalizeRenderableChild = (value) => {
       const nestedChildren = candidate.props.children;
       return normalizeRenderableChild(nestedChildren);
     }
+    for (const key of ["children", "label", "title", "content", "text", "value"]) {
+      if (key in candidate) {
+        return normalizeRenderableChild(candidate[key]);
+      }
+    }
   }
   return null;
 };

package/dist/static-engine.d.ts

@@ -3,10 +3,10 @@ import React__default from 'react';
 import { UIEngineProps, UINodeWrapperProps } from '@arkcit/engine-core';
 import { UINode } from '@arkcit/engine-schema';
 import { UIRuntimeAdapter } from '@arkcit/engine-runtime';
-import { r as renderReactNode } from './renderReactNode-DmxD8hot.js';
+import { a as RenderReactNodeDependencies } from './renderReactNode-xwA81IXf.js';
 import '@arkcit/engine-render-layer';
 
-type RenderSafeNodeArgs<TInlineEditing> = {
+type StaticRenderSafeNodeArgs<TInlineEditing = unknown> = {
     node: UINode;
     registry: NonNullable<UIEngineProps["registry"]>;
     runtime: UIRuntimeAdapter;
@@ -36,14 +36,14 @@ type RenderSafeNodeArgs<TInlineEditing> = {
     NodeWrapper: React__default.ComponentType<UINodeWrapperProps>;
     isFormInteractiveTarget: (target: HTMLElement | null) => boolean;
 };
-type StaticReactWebEngineRootDependencies<TInlineEditing> = {
-    renderSafeNode: (args: RenderSafeNodeArgs<TInlineEditing>) => React__default.ReactNode;
+type StaticReactWebEngineRootDependencies<TInlineEditing = unknown> = {
+    renderSafeNode: (args: StaticRenderSafeNodeArgs<TInlineEditing>) => React__default.ReactNode;
     StudioNodeWrapper: React__default.ComponentType<UINodeWrapperProps>;
-    renderReactNodeDependencies: Parameters<typeof renderReactNode<TInlineEditing>>[0]["dependencies"];
+    renderReactNodeDependencies: RenderReactNodeDependencies<TInlineEditing>;
 };
-type StaticReactWebEngineRootArgs<TInlineEditing> = UIEngineProps & {
+type StaticReactWebEngineRootArgs<TInlineEditing = unknown> = UIEngineProps & {
     dependencies: StaticReactWebEngineRootDependencies<TInlineEditing>;
 };
 declare const StaticReactWebEngineRoot: <TInlineEditing = unknown>({ schema, registry, store, nodeWrapper, dependencies, }: StaticReactWebEngineRootArgs<TInlineEditing>) => react_jsx_runtime.JSX.Element;
 
-export { StaticReactWebEngineRoot };
+export { StaticReactWebEngineRoot, type StaticReactWebEngineRootArgs, type StaticReactWebEngineRootDependencies, type StaticRenderSafeNodeArgs };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arkcit/engine-react",
   "private": false,
-  "version": "0.3.7",
+  "version": "0.3.8",
   "type": "module",
   "sideEffects": false,
   "description": "React-specific renderer package for the Arkcit engine platform.",
@@ -75,10 +75,10 @@
     "test": "npm run test:smoke && npm run test:unit"
   },
   "dependencies": {
-    "@arkcit/engine-core": "^0.3.2",
-    "@arkcit/engine-render-layer": "^0.3.2",
-    "@arkcit/engine-runtime": "^0.3.1",
-    "@arkcit/engine-schema": "^0.3.2"
+    "@arkcit/engine-core": "^0.3.3",
+    "@arkcit/engine-render-layer": "^0.3.3",
+    "@arkcit/engine-runtime": "^0.3.2",
+    "@arkcit/engine-schema": "^0.3.3"
   },
   "peerDependencies": {
     "react": "^19.1.0",

package/dist/renderReactNode-DmxD8hot.d.ts

@@ -1,109 +0,0 @@
-import React__default from 'react';
-import { ComponentRegistry } from '@arkcit/engine-core';
-import { UINode } from '@arkcit/engine-schema';
-import { UIRuntimeAdapter } from '@arkcit/engine-runtime';
-import { ContentCompositionPlan, RenderDirectivePlan, NavigationCompositionPlan, FinalRenderPlan } from '@arkcit/engine-render-layer';
-
-type RenderReactNodeArgs<TInlineEditing = unknown> = {
-    node: UINode;
-    runtime: UIRuntimeAdapter;
-    registry: ComponentRegistry;
-    schemaNodes: UINode[];
-    renderSafeNode: (node: UINode) => React__default.ReactNode;
-    internalStudioNodeTypes: Set<string>;
-    overlaysByNodeId: Record<string, unknown>;
-    onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
-    isStudioRendererContext: boolean;
-    dropdownOpenByNodeId: Record<string, boolean>;
-    setDropdownOpenByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, boolean>>>;
-    captureFieldFocus: (target: EventTarget | null) => void;
-    selectedNodeId: string | null | undefined;
-    wizardActiveStepByNodeId: Record<string, string>;
-    accordionOpenIdsByNodeId: Record<string, string[]>;
-    expandablePanelOpenByNodeId: Record<string, boolean>;
-    setWizardActiveStepByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, string>>>;
-    setAccordionOpenIdsByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, string[]>>>;
-    setExpandablePanelOpenByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, boolean>>>;
-    onNodeClick?: (nodeId: string) => void;
-    setInlineEditing: React__default.Dispatch<React__default.SetStateAction<TInlineEditing | null>>;
-    studioSizing?: {
-        widthPct: number | null;
-        heightPct: number | null;
-        heightPx: number | null;
-    };
-    dependencies: {
-        applyStudioOverlayComponentProps: (args: {
-            node: UINode;
-            componentProps: Record<string, unknown>;
-            runtime: UIRuntimeAdapter;
-            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>>>;
-        }) => void;
-        applyContentComposition: (args: {
-            node: UINode;
-            componentProps: Record<string, unknown>;
-            isStudioRendererContext: boolean;
-            internalStudioNodeTypes: Set<string>;
-            schemaNodes: UINode[];
-            onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
-            captureFieldFocus: (target: EventTarget | null) => void;
-            renderSafeNode: (node: UINode) => React__default.ReactNode;
-            normalizeRenderableChild: (value: unknown) => React__default.ReactNode;
-            findNodeById: (nodeId: string, nodes: UINode[]) => UINode | null;
-            runtime: UIRuntimeAdapter;
-            plans?: ContentCompositionPlan[];
-        }) => React__default.ReactNode | null;
-        applyRenderDirectives: (args: {
-            node: UINode;
-            componentProps: Record<string, unknown>;
-            renderBindingProps: Record<string, unknown>;
-            runtime: UIRuntimeAdapter;
-            plans?: RenderDirectivePlan[];
-        }) => void;
-        applyNavigationComposition: (args: {
-            node: UINode;
-            componentProps: Record<string, unknown>;
-            isStudioRendererContext: boolean;
-            selectedNodeId: string | null;
-            wizardActiveStepByNodeId: Record<string, string>;
-            accordionOpenIdsByNodeId: Record<string, string[]>;
-            expandablePanelOpenByNodeId: Record<string, boolean>;
-            runtime: UIRuntimeAdapter;
-            setWizardActiveStepByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, string>>>;
-            setAccordionOpenIdsByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, string[]>>>;
-            setExpandablePanelOpenByNodeId: React__default.Dispatch<React__default.SetStateAction<Record<string, boolean>>>;
-            onNodeClick?: (nodeId: string) => void;
-            onInlineTextEdit?: (nodeId: string, propName: string, value: unknown) => void;
-            renderSafeNode: (node: UINode) => React__default.ReactNode;
-            normalizeRenderableChild: (value: unknown) => React__default.ReactNode;
-            captureFieldFocus: (target: EventTarget | null) => void;
-            setInlineEditing: React__default.Dispatch<React__default.SetStateAction<TInlineEditing | null>>;
-            internalStudioNodeTypes: Set<string>;
-            plans?: NavigationCompositionPlan[];
-        }) => void;
-        finalizeRenderedNode: (args: {
-            node: UINode;
-            children: React__default.ReactNode[] | undefined;
-            componentProps: Record<string, unknown>;
-            registryComponent: React__default.ComponentType<Record<string, unknown>>;
-            runtime: UIRuntimeAdapter;
-            isStudioRendererContext: boolean;
-            studioSizing?: {
-                widthPct: number | null;
-                heightPct: number | null;
-                heightPx: number | null;
-            };
-            plans?: FinalRenderPlan[];
-        }) => React__default.ReactNode | null;
-        normalizeRenderableChild: (value: unknown) => React__default.ReactNode;
-        findNodeById: (nodeId: string, nodes: UINode[]) => UINode | null;
-    };
-};
-declare const renderReactNode: <TInlineEditing = unknown>({ node, runtime, registry, schemaNodes, renderSafeNode, internalStudioNodeTypes, overlaysByNodeId, onInlineTextEdit, isStudioRendererContext, dropdownOpenByNodeId, setDropdownOpenByNodeId, captureFieldFocus, selectedNodeId, wizardActiveStepByNodeId, accordionOpenIdsByNodeId, expandablePanelOpenByNodeId, setWizardActiveStepByNodeId, setAccordionOpenIdsByNodeId, setExpandablePanelOpenByNodeId, onNodeClick, setInlineEditing, studioSizing, dependencies, }: RenderReactNodeArgs<TInlineEditing>) => React__default.ReactNode;
-
-export { renderReactNode as r };