@jsonui/core 0.9.1 → 0.10.9

package/dist/index.d.ts

@@ -1,340 +1,245 @@
-import * as React$1 from 'react';
-import React__default from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as redux from 'redux';
+import { ValidateFunction } from 'ajv';
 
-declare const SEPARATOR = "/";
-declare const STORE_ERROR_POSTFIX = ".error";
-declare const STORE_TOUCH_POSTFIX = ".touch";
-declare const PATH_MODIFIERS_KEY = "$pathModifiers";
-declare const MODIFIER_KEY = "$modifier";
+/**
+ * Tree-shaped state management with multiple stores.
+ * Similar to Redux but tailored for JSON UI: per-store trees, JSON Pointer paths.
+ *
+ * Store paths are unbounded and can be arbitrarily nested (objects and arrays),
+ * e.g. /a/b/c/2/d/e/0/f. Logical paths are resolved via resolveStorePath and
+ * applied consistently in get/set.
+ */
+
+type StoreState = Record<string, unknown>;
+type StoreChangeListener = (storeName: string, logicalPath: string) => void;
+declare class FormStore {
+    private state;
+    private changeListeners;
+    getState(): Readonly<StoreState>;
+    /**
+     * Logical JsonUI stores snapshot — same shape as `JsonUI` `defaultValues`:
+     * `{ data: {...}, "data.touch": {...}, "data.error": {...} }`.
+     * Omits the internal `/storeRoot` wrapper returned by {@link getState}.
+     */
+    getLogicalStoresMap(): Record<string, JSONValue>;
+    /**
+     * Initialise a logical store root without marking fields as touched.
+     */
+    initializeStore(storeName: string, value: JSONValue): void;
+    private getByPointer;
+    private setByPointer;
+    /**
+     * Convenience helpers that work with logical store names and logical paths,
+     * instead of requiring callers to compose `/storeRoot/{storeName}/...`.
+     *
+     * Store isolation: each storeName (e.g. "data", "data.error", "data.touch") is
+     * a distinct store. get/set only read/write that store's subtree;
+     * "data.error" cannot access "data" or any other store.
+     *
+     * When trackTouch is true, set also writes to `${storeName}.touch` at
+     * the same logicalPath; path normalization applies (no empty segments).
+     */
+    set(storeName: string, logicalPath: string, value: unknown, trackTouch?: boolean): void;
+    get(storeName: string, logicalPath: string): unknown;
+    setForStore(storeName: string, logicalPath: string, value: unknown, trackTouch?: boolean): void;
+    getForStore(storeName: string, logicalPath: string): unknown;
+    private notify;
+    subscribeChange(listener: StoreChangeListener): () => void;
+    private notifyChange;
+}
+/**
+ * Resolve a path for a given store, using pathModifiers (from list context) and currentPath for relative paths.
+ * - Absolute path: /firstname -> unchanged (then normalized).
+ * - Relative path: firstname -> resolved against currentPath (or pathModifiers[storeName] when in list context).
+ * - pathModifiers apply per store: only pathModifiers[storeName] is used for that store; "data.error" cannot
+ *   access "data" or any other store.
+ * Returns a normalized path (no empty segments, no trailing slash).
+ */
+declare const resolveStorePath: (pathStr: string, currentPath: string, pathModifiers?: PathModifier, storeName?: string) => string;
+
+declare const V_COMP = "$comp";
+declare const V_CHILDREN = "$children";
 declare const ACTION_KEY = "$action";
-declare const REF_ASSETS = "$assetsRef";
-declare const REF_LOCALES = "$locales";
-declare const REF_VALIDATES = "$validations";
-declare const STYLE_WEB_NAME = "styleWeb";
-declare const STYLE_RN_NAME = "styleRN";
-declare const REDUX_GET_FUNCTION = "get";
-declare const REDUX_SET_FUNCTION = "set";
-declare const REDUX_FUNCTIONS: string[];
-declare const PATHNAME = "path";
-declare const SIMPLE_DATA_TYPES: string[];
-declare const V_CHILDREN_NAME = "$children";
-declare const V_COMP_NAME = "$comp";
+declare const MODIFIER_KEY = "$modifier";
+declare const PATH_MODIFIERS_KEY = "$pathModifiers";
 declare const LIST_SEMAPHORE = "$isList";
 declare const LIST_ITEM = "$listItem";
+/** Main JsonUI list pagination keys (parity). */
 declare const LIST_PAGE = "$page";
 declare const LIST_ITEM_PER_PAGE = "$itemPerPage";
 declare const LIST_LENGTH = "$listLength";
-declare const LIST_ITEM_PER_PAGE_DEFAULT = 10;
-declare const REDUX_PATHS = "$$reduxPaths";
-declare const V_CHILDREN_PREFIX = "$child";
-declare const PARENT_PROP_NAME = "__parentprop";
-declare const CURRENT_PATH_NAME = "__currentPaths";
-declare const REDUX_GET_SUBSCRIBERS_NAME = "__subscriberPaths";
-declare const UNDEFINED_COMP_NAME = "_Undefined";
-declare const PRIMITIVE_COMP_NAME = "_PrimitiveProp";
-declare const FRAGMENT_COMP_NAME = "Fragment";
+/** Field-level inline validation spec key on a node. */
+declare const V_VALIDATIONS = "$validations";
+declare const ERROR_STORE_SUFFIX = ".error";
+/** Shadow store for field touched state (aligned with main JsonUI `.touch`). */
+declare const TOUCH_STORE_SUFFIX = ".touch";
 
-declare const constants_ACTION_KEY: typeof ACTION_KEY;
-declare const constants_CURRENT_PATH_NAME: typeof CURRENT_PATH_NAME;
-declare const constants_FRAGMENT_COMP_NAME: typeof FRAGMENT_COMP_NAME;
-declare const constants_LIST_ITEM: typeof LIST_ITEM;
-declare const constants_LIST_ITEM_PER_PAGE: typeof LIST_ITEM_PER_PAGE;
-declare const constants_LIST_ITEM_PER_PAGE_DEFAULT: typeof LIST_ITEM_PER_PAGE_DEFAULT;
-declare const constants_LIST_LENGTH: typeof LIST_LENGTH;
-declare const constants_LIST_PAGE: typeof LIST_PAGE;
-declare const constants_LIST_SEMAPHORE: typeof LIST_SEMAPHORE;
-declare const constants_MODIFIER_KEY: typeof MODIFIER_KEY;
-declare const constants_PARENT_PROP_NAME: typeof PARENT_PROP_NAME;
-declare const constants_PATHNAME: typeof PATHNAME;
-declare const constants_PATH_MODIFIERS_KEY: typeof PATH_MODIFIERS_KEY;
-declare const constants_PRIMITIVE_COMP_NAME: typeof PRIMITIVE_COMP_NAME;
-declare const constants_REDUX_FUNCTIONS: typeof REDUX_FUNCTIONS;
-declare const constants_REDUX_GET_FUNCTION: typeof REDUX_GET_FUNCTION;
-declare const constants_REDUX_GET_SUBSCRIBERS_NAME: typeof REDUX_GET_SUBSCRIBERS_NAME;
-declare const constants_REDUX_PATHS: typeof REDUX_PATHS;
-declare const constants_REDUX_SET_FUNCTION: typeof REDUX_SET_FUNCTION;
-declare const constants_REF_ASSETS: typeof REF_ASSETS;
-declare const constants_REF_LOCALES: typeof REF_LOCALES;
-declare const constants_REF_VALIDATES: typeof REF_VALIDATES;
-declare const constants_SEPARATOR: typeof SEPARATOR;
-declare const constants_SIMPLE_DATA_TYPES: typeof SIMPLE_DATA_TYPES;
-declare const constants_STORE_ERROR_POSTFIX: typeof STORE_ERROR_POSTFIX;
-declare const constants_STORE_TOUCH_POSTFIX: typeof STORE_TOUCH_POSTFIX;
-declare const constants_STYLE_RN_NAME: typeof STYLE_RN_NAME;
-declare const constants_STYLE_WEB_NAME: typeof STYLE_WEB_NAME;
-declare const constants_UNDEFINED_COMP_NAME: typeof UNDEFINED_COMP_NAME;
-declare const constants_V_CHILDREN_NAME: typeof V_CHILDREN_NAME;
-declare const constants_V_CHILDREN_PREFIX: typeof V_CHILDREN_PREFIX;
-declare const constants_V_COMP_NAME: typeof V_COMP_NAME;
-declare namespace constants {
-  export {
-    constants_ACTION_KEY as ACTION_KEY,
-    constants_CURRENT_PATH_NAME as CURRENT_PATH_NAME,
-    constants_FRAGMENT_COMP_NAME as FRAGMENT_COMP_NAME,
-    constants_LIST_ITEM as LIST_ITEM,
-    constants_LIST_ITEM_PER_PAGE as LIST_ITEM_PER_PAGE,
-    constants_LIST_ITEM_PER_PAGE_DEFAULT as LIST_ITEM_PER_PAGE_DEFAULT,
-    constants_LIST_LENGTH as LIST_LENGTH,
-    constants_LIST_PAGE as LIST_PAGE,
-    constants_LIST_SEMAPHORE as LIST_SEMAPHORE,
-    constants_MODIFIER_KEY as MODIFIER_KEY,
-    constants_PARENT_PROP_NAME as PARENT_PROP_NAME,
-    constants_PATHNAME as PATHNAME,
-    constants_PATH_MODIFIERS_KEY as PATH_MODIFIERS_KEY,
-    constants_PRIMITIVE_COMP_NAME as PRIMITIVE_COMP_NAME,
-    constants_REDUX_FUNCTIONS as REDUX_FUNCTIONS,
-    constants_REDUX_GET_FUNCTION as REDUX_GET_FUNCTION,
-    constants_REDUX_GET_SUBSCRIBERS_NAME as REDUX_GET_SUBSCRIBERS_NAME,
-    constants_REDUX_PATHS as REDUX_PATHS,
-    constants_REDUX_SET_FUNCTION as REDUX_SET_FUNCTION,
-    constants_REF_ASSETS as REF_ASSETS,
-    constants_REF_LOCALES as REF_LOCALES,
-    constants_REF_VALIDATES as REF_VALIDATES,
-    constants_SEPARATOR as SEPARATOR,
-    constants_SIMPLE_DATA_TYPES as SIMPLE_DATA_TYPES,
-    constants_STORE_ERROR_POSTFIX as STORE_ERROR_POSTFIX,
-    constants_STORE_TOUCH_POSTFIX as STORE_TOUCH_POSTFIX,
-    constants_STYLE_RN_NAME as STYLE_RN_NAME,
-    constants_STYLE_WEB_NAME as STYLE_WEB_NAME,
-    constants_UNDEFINED_COMP_NAME as UNDEFINED_COMP_NAME,
-    constants_V_CHILDREN_NAME as V_CHILDREN_NAME,
-    constants_V_CHILDREN_PREFIX as V_CHILDREN_PREFIX,
-    constants_V_COMP_NAME as V_COMP_NAME,
-  };
-}
+/**
+ * JSON UI type definitions (framework-agnostic).
+ */
 
-type UIDefinition = any;
-type Path = string;
-type ArraysType = any[];
-type WrapperType = React__default.ElementType;
-type PropValue = PropsType | ArraysType | string | null | boolean | number | undefined | PathModifiersType;
-interface PathModifierType {
+type JsonUIValue = string | number | boolean | null | JsonUINode | JsonUIValue[];
+type JSONValue = string | number | boolean | null | JSONObject | JSONValue[];
+interface JSONObject {
+    [key: string]: JSONValue;
+}
+interface JsonUINode {
+    [key: string]: unknown;
+    [V_COMP]?: string;
+    [V_CHILDREN]?: JsonUIValue;
+}
+type ModifierHandler = (params: Record<string, unknown>, context: ModifierContext) => unknown | Promise<unknown>;
+type ActionHandler = (params: Record<string, unknown>, context: ActionContext) => void | Promise<void>;
+type TranslationsMap = Record<string, Record<string, string> | undefined>;
+type PathModifier = Record<string, {
     path: string;
-}
-interface PathModifiersType {
-    [key: string]: PathModifierType;
-}
-interface PropsType {
-    [key: string]: PropValue;
-    [PATH_MODIFIERS_KEY]?: PathModifiersType;
-}
-interface PathType {
-    path: string[];
-    level: number;
-}
-type PathsType = PathType[];
-interface ValidationType {
+}>;
+interface ModifierContext {
+    formStore: FormStore;
+    currentPath: string;
+    pathModifiers?: PathModifier;
+    validators?: unknown;
+    translations?: TranslationsMap;
+    defaultLanguage?: string;
+    activeLanguage?: string;
+}
+type ComponentActionProps = Record<string, unknown>;
+interface ActionContext extends ModifierContext {
+    componentProps: ComponentActionProps;
+    validators?: ValidationRegistry;
+}
+type ModifierMap = Record<string, ModifierHandler | undefined>;
+type ActionMap = Record<string, ActionHandler | undefined>;
+/** Emitted when JsonUI unmounts or when model/defaultValues/id changes (main parity). */
+interface OnStateExportProps {
+    id?: string;
+    /** Same shape as `JsonUI` `defaultValues`: logical stores `{ data: {...}, "data.touch": {...}, ... }` (no internal `storeRoot` wrapper). */
+    formState: JSONValue;
+}
+type OnStateExportType = (arg: OnStateExportProps) => void;
+type StorePathDependency = {
     store: string;
     path: string;
-    schema: any;
-}
-declare enum ReduxPathTypeEnum {
-    ERROR = "ERROR",
-    TOUCH = "TOUCH",
-    NORMAL = "NORMAL"
-}
-interface ReduxPath {
-    store?: string;
-    path?: string;
-    type?: ReduxPathTypeEnum;
-    jsonataDef?: string;
-}
-type JsonUIComponentType = React__default.FC<any> | typeof React__default.Component | ((prop: any) => number | null | undefined | string);
-interface JsonUIComponentsType {
-    [key: string]: JsonUIComponentType;
-}
-type JsonUIFunctionType = (attr: any, props: any, callerArgs: any, stock: any) => void | any;
-interface JsonUIFunctions {
-    [key: string]: JsonUIFunctionType;
+};
+type ResolvedRenderNodeState = {
+    props: Record<string, unknown>;
+    resolvedSlots: Record<string, unknown>;
+};
+interface ValidationRule {
+    schema: unknown;
+    path: string;
+    store: string;
 }
+/** Nested maps may be missing until first validator is registered for a path. */
+type ValidationRegistry = Partial<Record<string, Partial<Record<string, ValidateFunction[]>>>>;
 
-interface NewStockType {
-    components: JsonUIComponentsType;
-    functions: JsonUIFunctions;
-}
-type InitType = (prop: NewStockType) => void;
-type RegisterFunctionType = (key: string, value: JsonUIFunctionType) => void;
-type RegisterComponentType = (key: string, value: JsonUIComponentType) => void;
-type CallFunctionType = (name: string, attr?: any, props?: any, callerArgs?: any) => any;
-type GetComponentType = (componentName: string) => JsonUIComponentType;
-declare class Stock {
-    stock: NewStockType;
-    Wrapper: React.ElementType;
-    reduxStore: any;
-    validations: any;
-    constructor(newStock: NewStockType, Wrapper: React.ElementType, reduxStore: any);
-    init: InitType;
-    registerComponent: RegisterComponentType;
-    registerFunction: RegisterFunctionType;
-    callFunction: CallFunctionType;
-    getComponent: GetComponentType;
-}
+declare const actions: ActionMap;
 
-interface OwnTraverse {
-    key: string;
-    value: PropsType;
-    path: string[];
-    parent: PropsType;
-    level: number;
-}
-declare const getFilteredPath: ({ [c.PARENT_PROP_NAME]: parentComp, ...propsNew }: PropsType, func: (filterProps: OwnTraverse) => boolean) => OwnTraverse[];
-declare const actionBuilder: (props: PropsType, stock: InstanceType<typeof Stock>) => void;
-declare const calculatePropsFromModifier: (props: PropsType, stock: InstanceType<typeof Stock>) => ReduxPath[];
-declare const getCurrentPaths: (props: PropsType, pathModifier: PathModifiersType) => PathModifiersType;
-declare const normalisePrimitives: (props: PropsType, parentComp?: any) => any;
-declare const getRootWrapperProps: (props: PropsType, stock: InstanceType<typeof Stock>) => void;
-declare const isChildrenProp: (propName?: string) => boolean;
-declare const getParentProps: (props: PropsType) => PropsType;
-declare const getPropsChildrenFilter: ({ props, filter }: {
-    props: PropsType;
-    filter: "onlyChildren" | "withoutChildren";
-}) => PropsType;
-declare const getChildrensForRoot: (props: PropsType, children: any, Wrapper: WrapperType) => react_jsx_runtime.JSX.Element | react_jsx_runtime.JSX.Element[] | undefined;
-declare const generateChildren: (props: PropsType, { Wrapper }: InstanceType<typeof Stock>) => PropValue | react_jsx_runtime.JSX.Element;
-declare const generateNewChildren: (props: PropsType, { Wrapper }: InstanceType<typeof Stock>) => react_jsx_runtime.JSX.Element | react_jsx_runtime.JSX.Element[] | undefined;
-declare const isTechnicalProp: (propName: string) => boolean;
-declare const removeTechnicalProps: (changeableProps: any) => any;
+/**
+ * Expands simplified node format into full JSON UI node so components receive
+ * value, onChange, error, etc. without the model having to specify every binding.
+ *
+ * When a node has store + path (non-empty store, string path), we add:
+ * - value: { $modifier: 'get', store, path }
+ * - onChange: { $action: 'set', store, path }
+ * - error / fieldErrors: { $modifier: 'get', store: store + '.error', path }
+ * - fieldTouched: { $modifier: 'get', store: store + '.touch', path }
+ *
+ * The component is unchanged; RenderNode uses the expanded node for prop
+ * resolution and the expanded props are passed through normally.
+ */
 
-declare const wrapperUtil_actionBuilder: typeof actionBuilder;
-declare const wrapperUtil_calculatePropsFromModifier: typeof calculatePropsFromModifier;
-declare const wrapperUtil_generateChildren: typeof generateChildren;
-declare const wrapperUtil_generateNewChildren: typeof generateNewChildren;
-declare const wrapperUtil_getChildrensForRoot: typeof getChildrensForRoot;
-declare const wrapperUtil_getCurrentPaths: typeof getCurrentPaths;
-declare const wrapperUtil_getFilteredPath: typeof getFilteredPath;
-declare const wrapperUtil_getParentProps: typeof getParentProps;
-declare const wrapperUtil_getPropsChildrenFilter: typeof getPropsChildrenFilter;
-declare const wrapperUtil_getRootWrapperProps: typeof getRootWrapperProps;
-declare const wrapperUtil_isChildrenProp: typeof isChildrenProp;
-declare const wrapperUtil_isTechnicalProp: typeof isTechnicalProp;
-declare const wrapperUtil_normalisePrimitives: typeof normalisePrimitives;
-declare const wrapperUtil_removeTechnicalProps: typeof removeTechnicalProps;
-declare namespace wrapperUtil {
-  export {
-    wrapperUtil_actionBuilder as actionBuilder,
-    wrapperUtil_calculatePropsFromModifier as calculatePropsFromModifier,
-    wrapperUtil_generateChildren as generateChildren,
-    wrapperUtil_generateNewChildren as generateNewChildren,
-    wrapperUtil_getChildrensForRoot as getChildrensForRoot,
-    wrapperUtil_getCurrentPaths as getCurrentPaths,
-    wrapperUtil_getFilteredPath as getFilteredPath,
-    wrapperUtil_getParentProps as getParentProps,
-    wrapperUtil_getPropsChildrenFilter as getPropsChildrenFilter,
-    wrapperUtil_getRootWrapperProps as getRootWrapperProps,
-    wrapperUtil_isChildrenProp as isChildrenProp,
-    wrapperUtil_isTechnicalProp as isTechnicalProp,
-    wrapperUtil_normalisePrimitives as normalisePrimitives,
-    wrapperUtil_removeTechnicalProps as removeTechnicalProps,
-  };
-}
+/**
+ * Returns an expanded node with value, onChange, error, fieldErrors, fieldTouched
+ * derived from store + path. Strips store and path from the result so they are
+ * not passed as component props.
+ * If the node is not simplified, returns the same node reference.
+ */
+declare const expandSimplifiedNode: (node: JsonUINode) => JsonUINode;
 
-declare const findLastIndex: (arr: any[], func: any) => number;
-declare const drop: (arr: any[], n?: number) => any[];
-declare const isNumber: (a: any) => a is number;
-declare const jsonPointerFix: (path?: string) => string;
-declare const jsonPointerGet: (json: any, path?: string) => any;
-declare const jsonPointerSet: (json: any, path?: string, value?: any) => any;
-declare const pathArrayToPathString: (array: (string | number)[]) => string;
-declare const pathArrayToJsonPointer: (array: (string | number)[]) => string;
-declare function isOnlyObject(item: any): boolean;
-declare const mergePath: (target: any, newState: any) => any;
-declare const changeRelativePath: (path: string) => string;
 /**
- * Deep merge two objects.
- * @param target
- * @param ...sources
+ * JsonUI list pagination: maps `$page`, `$itemPerPage`, and `$listLength` to a slice of the backing list.
+ *
+ * Computes which indices belong on the current page. `page`, `itemPerPage`, and `listLength` are
+ * coerced to non-negative integers; invalid or missing values use defaults (`page` → 0,
+ * `itemPerPage` → effective list length, `listLength` → `realDataLength` when omitted).
+ * If `page * itemPerPage` exceeds `listLength`, offset resets to 0 (parity with reference impl).
+ *
+ * @param args.realDataLength - Actual length of the list data in memory (caps defaults).
+ * @param args.page - Zero-based page index from the model (`$page`).
+ * @param args.itemPerPage - Page size from the model (`$itemPerPage`).
+ * @param args.listLength - Logical list length from the model (`$listLength`); may differ from `realDataLength`.
+ * @returns `offset` and `end` for half-open `[offset, end)` slicing, plus `indices` listing each index in range.
+ * @see computeRenderNodeSlotChildren in @jsonui/react
  */
-declare function mergeDeep(target: any, ...sources: any): any;
-declare const collectObjMerge: (refConst: string, json: any) => {};
-declare const collectObjToArray: (refConst: string, json: any, flatten?: boolean) => any[];
-declare const isValidJson: (d: any) => boolean;
-declare const isPrimitiveValue: (value: any, emptyStringAllowed?: boolean) => boolean;
-declare const hasLeaf: (obj: any, emptyStringAllowed?: boolean) => boolean;
+interface ComputeListSliceRangeArgs {
+    realDataLength: number;
+    page?: unknown;
+    itemPerPage?: unknown;
+    listLength?: unknown;
+}
+interface ComputeListSliceRangeResult {
+    offset: number;
+    end: number;
+    indices: number[];
+}
+declare const computeListSliceRange: ({ realDataLength, page: pageRaw, itemPerPage: itemPerPageRaw, listLength: listLengthRaw, }: ComputeListSliceRangeArgs) => ComputeListSliceRangeResult;
 
-declare const jsonUtils_changeRelativePath: typeof changeRelativePath;
-declare const jsonUtils_collectObjMerge: typeof collectObjMerge;
-declare const jsonUtils_collectObjToArray: typeof collectObjToArray;
-declare const jsonUtils_drop: typeof drop;
-declare const jsonUtils_findLastIndex: typeof findLastIndex;
-declare const jsonUtils_hasLeaf: typeof hasLeaf;
-declare const jsonUtils_isNumber: typeof isNumber;
-declare const jsonUtils_isOnlyObject: typeof isOnlyObject;
-declare const jsonUtils_isPrimitiveValue: typeof isPrimitiveValue;
-declare const jsonUtils_isValidJson: typeof isValidJson;
-declare const jsonUtils_jsonPointerFix: typeof jsonPointerFix;
-declare const jsonUtils_jsonPointerGet: typeof jsonPointerGet;
-declare const jsonUtils_jsonPointerSet: typeof jsonPointerSet;
-declare const jsonUtils_mergeDeep: typeof mergeDeep;
-declare const jsonUtils_mergePath: typeof mergePath;
-declare const jsonUtils_pathArrayToJsonPointer: typeof pathArrayToJsonPointer;
-declare const jsonUtils_pathArrayToPathString: typeof pathArrayToPathString;
-declare namespace jsonUtils {
-  export {
-    jsonUtils_changeRelativePath as changeRelativePath,
-    jsonUtils_collectObjMerge as collectObjMerge,
-    jsonUtils_collectObjToArray as collectObjToArray,
-    jsonUtils_drop as drop,
-    jsonUtils_findLastIndex as findLastIndex,
-    jsonUtils_hasLeaf as hasLeaf,
-    jsonUtils_isNumber as isNumber,
-    jsonUtils_isOnlyObject as isOnlyObject,
-    jsonUtils_isPrimitiveValue as isPrimitiveValue,
-    jsonUtils_isValidJson as isValidJson,
-    jsonUtils_jsonPointerFix as jsonPointerFix,
-    jsonUtils_jsonPointerGet as jsonPointerGet,
-    jsonUtils_jsonPointerSet as jsonPointerSet,
-    jsonUtils_mergeDeep as mergeDeep,
-    jsonUtils_mergePath as mergePath,
-    jsonUtils_pathArrayToJsonPointer as pathArrayToJsonPointer,
-    jsonUtils_pathArrayToPathString as pathArrayToPathString,
-  };
-}
+declare const getOwnPathModifiers: (node: JsonUINode) => PathModifier | undefined;
+declare const mergeEffectivePathModifiers: ({ ownPathModifiers, pathModifiers, currentPath, }: {
+    ownPathModifiers?: PathModifier;
+    pathModifiers?: PathModifier;
+    currentPath: string;
+}) => PathModifier | undefined;
 
-interface I18nResources {
-    [key: string]: {
-        translation: {
-            [key: string]: string;
-        };
-    };
-}
-interface I18nProps {
-    language?: string;
-    resources?: I18nResources;
-    keyPrefix?: string;
-    keyPostfix?: string;
-    nonExistsHandler?: (key: string) => void;
-}
-declare class I18n {
-    language: string;
-    languages: string[];
-    resources?: I18nResources;
-    keyPrefix?: string;
-    keyPostfix?: string;
-    nonExistsHandler?: (key: string) => void;
-    availableLanguageKey?: string;
-    constructor({ language, resources, nonExistsHandler, keyPrefix, keyPostfix }: I18nProps);
-    getLocales: () => string;
-    t: (key: any, options?: any, language?: string | null) => any;
-}
+/** Segment-aware path overlap check (aligned with validation.ts). */
+declare const isPathPrefix: (rulePath: string, targetPath: string) => boolean;
 
-declare const StockContext: React$1.Context<Stock | null>;
-declare const PathModifierContext: React$1.Context<{}>;
+/** Breakpoint keys for responsive style objects */
+type BreakpointKey = 'base' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/** Platform for style resolution */
+type StylePlatform = 'web' | 'native';
+/** Default breakpoint width thresholds (min-width in px) */
+declare const DEFAULT_BREAKPOINTS: Record<BreakpointKey, number>;
+/** Order for merging: base first, then xs..xl */
+declare const BREAKPOINT_ORDER: BreakpointKey[];
 
-declare const compSelectorHook: (currentPaths: PathModifiersType, subscriberPaths: ReduxPath[]) => (state: any) => any[] | undefined;
+interface RunRenderNodeResolutionArgs {
+    node: JsonUINode;
+    modifiers: ModifierMap;
+    ctx: ModifierContext;
+    currentPath: string;
+    effectivePathModifiers?: PathModifier;
+    stylePlatform: StylePlatform;
+    styleBreakpoint?: BreakpointKey;
+    /** Store name from the simplified component's own `store` prop, if any. */
+    componentStore?: string;
+    /** Logical path from the simplified component's own `path` prop, if any. */
+    componentPath?: string;
+}
+declare const runRenderNodeResolution: ({ node, modifiers, ctx, currentPath, effectivePathModifiers, stylePlatform, styleBreakpoint, componentStore, componentPath, }: RunRenderNodeResolutionArgs) => Promise<{
+    state: ResolvedRenderNodeState;
+    deps: StorePathDependency[];
+}>;
 
-declare const _default: {
-    get: JsonUIFunctionType;
-    set: JsonUIFunctionType;
-    jsonata: JsonUIFunctionType;
-};
+declare const resolveAction: (value: unknown, actions: ActionMap, modifiers: ModifierMap, ctx: ActionContext) => ((e: unknown) => Promise<void>) | undefined;
+
+declare const buildValidationRegistry: (rules?: ValidationRule[]) => ValidationRegistry;
 
-declare const rootReducer: redux.Reducer<{
-    root: any;
-}, redux.AnyAction, Partial<{
-    root: any;
-}>>;
+declare const modifiers: ModifierMap;
+
+/**
+ * Minimal JSON Pointer implementation (RFC 6901).
+ * Supports get, set, and path resolution (absolute, relative, ./ ../).
+ *
+ * Paths and nesting are unbounded: e.g. /a/b/c/0/d/e/1/f is valid;
+ * segments can be object keys or array indices (numeric strings).
+ */
+/**
+ * Normalize a path: remove empty segments and trailing/leading slashes.
+ * Prevents accidental keys like "" from paths such as "//" or "/a/".
+ * Does not decode segments (e.g. ~1 stays so one segment is preserved).
+ */
+declare const normalizePath: (pathStr: string) => string;
 
-export { I18n, PathModifierContext, ReduxPathTypeEnum, Stock, StockContext, compSelectorHook, constants, _default as stockFunctions, rootReducer as storeReducers, jsonUtils as utils, wrapperUtil };
-export type { ArraysType, JsonUIComponentsType, JsonUIFunctionType, JsonUIFunctions, Path, PathModifierType, PathModifiersType, PathType, PathsType, PropValue, PropsType, ReduxPath, UIDefinition, ValidationType, WrapperType };
+export { ACTION_KEY, BREAKPOINT_ORDER, DEFAULT_BREAKPOINTS, ERROR_STORE_SUFFIX, FormStore, LIST_ITEM, LIST_ITEM_PER_PAGE, LIST_LENGTH, LIST_PAGE, LIST_SEMAPHORE, MODIFIER_KEY, PATH_MODIFIERS_KEY, TOUCH_STORE_SUFFIX, V_CHILDREN, V_COMP, V_VALIDATIONS, actions, buildValidationRegistry, computeListSliceRange, expandSimplifiedNode, getOwnPathModifiers, isPathPrefix, mergeEffectivePathModifiers, modifiers, normalizePath, resolveAction, resolveStorePath, runRenderNodeResolution };
+export type { ActionContext, ActionHandler, ActionMap, BreakpointKey, JSONObject, JSONValue, JsonUINode, ModifierContext, ModifierHandler, ModifierMap, OnStateExportProps, OnStateExportType, PathModifier, ResolvedRenderNodeState, StorePathDependency, StylePlatform, TranslationsMap, ValidationRegistry, ValidationRule };