@plitzi/sdk-elements 0.30.19

package/dist/Element/helpers/getInteractions.d.ts

@@ -0,0 +1,3 @@
+import { Element, InteractionCallback, InteractionPostCallback } from '@plitzi/sdk-shared';
+declare const getInteractions: (attributes: Element["attributes"], definition: Element["definition"], callback: InteractionCallback["callback"], postCallback: InteractionPostCallback) => Record<string, InteractionCallback>;
+export default getInteractions;

package/dist/Element/helpers/getInteractions.mjs

@@ -0,0 +1,68 @@
+//#region src/Element/helpers/getInteractions.ts
+var e = (e, t, n, r) => ({ setState: {
+	action: "setState",
+	title: `Update ${t.label}`,
+	type: "callback",
+	callback: n,
+	postCallback: r,
+	preview: {},
+	params: {
+		category: {
+			label: "Category",
+			defaultValue: "attribute",
+			type: "select",
+			options: [{
+				value: "attribute",
+				label: "Attribute"
+			}, {
+				value: "state",
+				label: "State"
+			}]
+		},
+		key: {
+			label: "Key",
+			defaultValue: void 0,
+			type: "select",
+			when: (e) => e.category === "attribute" || e.category === "state",
+			options: (n) => {
+				let { category: r } = n;
+				return r === "attribute" ? Object.keys(e).map((e) => ({
+					value: e,
+					label: e
+				})) : r === "state" ? [{
+					value: "visibility",
+					label: "Visibility"
+				}, ...Object.keys(t.styleSelectors).map((e) => ({
+					value: `styleSelectors.${e}`,
+					label: `Selector - ${e}`
+				}))] : [];
+			}
+		},
+		value: {
+			label: "Value",
+			defaultValue: void 0,
+			type: (t) => typeof e[t.key] == "boolean" ? "select" : "text",
+			when: (e) => !!e.category,
+			options: (t) => {
+				let { key: n } = t;
+				return typeof e[n] == "boolean" ? [{
+					value: "true",
+					label: "True"
+				}, {
+					value: "false",
+					label: "False"
+				}] : Object.keys(e).map((e) => ({
+					value: e,
+					label: e
+				}));
+			}
+		},
+		revertOnFinish: {
+			label: "Revert changes after interaction",
+			defaultValue: !1,
+			type: "boolean"
+		}
+	}
+} });
+//#endregion
+export { e as default };

package/dist/Element/helpers/loadComponent.d.ts

@@ -0,0 +1,5 @@
+import { ComponentContextValue, ComponentPluginWithHOC } from '@plitzi/sdk-shared';
+declare const loadComponent: (url: string, pluginScope: string, registerCallback: ComponentContextValue["register"], autoRegister?: boolean, plitziJsxSkipHOC?: boolean) => () => Promise<{
+    default: ComponentPluginWithHOC;
+}>;
+export default loadComponent;

package/dist/Element/helpers/loadComponent.mjs

@@ -0,0 +1,26 @@
+import e from "../../elements/internal/NotFound/NotFound.mjs";
+import { generatePluginModule as t } from "./elementUtils.mjs";
+import n from "../hocs/withElement.mjs";
+import { nestedInject as r } from "../../Component/ComponentHelper.mjs";
+import { get as i } from "@plitzi/plitzi-ui/helpers";
+//#region src/Element/helpers/loadComponent.ts
+var a = /* @__PURE__ */ new Map(), o = (o, s, c, l = !0, u = !1) => async () => {
+	let d = `${o}::${s}`;
+	if (!a.get(d)) {
+		let e = t(o, o.endsWith(".mjs") || o.includes(".esm.") || o.includes(".module."), s).finally(() => {
+			a.delete(d);
+		});
+		a.set(d, {
+			promise: e,
+			timestamp: Date.now()
+		});
+	}
+	let f = await a.get(d)?.promise;
+	if (!f) return { default: e };
+	let { type: p, pluginSettings: m } = i(f, "default", {}), { version: h, initialItems: g, plugins: _ } = f;
+	if (!p) return { default: e };
+	let v = f.default;
+	return u || (v = n(f.default)), v.version = h, v.origin = "remote", v.type = p, v.initialItems = g, v.pluginSettings = m, v.plugins = r(_, "remote"), l && c(v), { default: v };
+};
+//#endregion
+export { o as default };

package/dist/Element/helpers/parseStyle.d.ts

@@ -0,0 +1,3 @@
+import { CSSProperties } from 'react';
+declare const parseStyle: (style?: string | CSSProperties) => CSSProperties | undefined;
+export default parseStyle;

package/dist/Element/helpers/parseStyle.mjs

@@ -0,0 +1,9 @@
+//#region src/Element/helpers/parseStyle.ts
+var e = (e = "") => {
+	if (e) return typeof e == "object" ? e : Object.fromEntries(e.split(";").map((e) => e.trim()).filter(Boolean).map((e) => {
+		let [t, n] = e.split(":").map((e) => e.trim());
+		return [t.replace(/-([a-z])/g, (e, t) => t.toUpperCase()), n];
+	}));
+};
+//#endregion
+export { e as default };

package/dist/Element/helpers/parseStyleSelectors.d.ts

@@ -0,0 +1,5 @@
+import { Element } from '@plitzi/sdk-shared';
+declare const parseStyleSelectors: (definition: Element["definition"]) => {
+    base: string;
+} & Omit<Record<string, string>, "base">;
+export default parseStyleSelectors;

package/dist/Element/helpers/parseStyleSelectors.mjs

@@ -0,0 +1,21 @@
+//#region src/Element/helpers/parseStyleSelectors.ts
+var e = /* @__PURE__ */ new Map(), t = (t) => {
+	let n = e.get(t);
+	return n || (n = RegExp(`(^|\\s)${t}(?=\\s|$)`), e.set(t, n)), n;
+}, n = (e) => {
+	let n = e.initialState?.styleVariant;
+	return Object.fromEntries(Object.entries(e.styleSelectors).map(([r, i]) => {
+		let a = r === "base" ? `plitzi__${e.type}` : `plitzi__${e.type}-${r}`;
+		if (typeof i != "string") return [r, i];
+		!t(e.type).test(i) && n?.[e.type]?.[r] && (i = i ? `${e.type} ${i}` : e.type);
+		let o = i.replace(/\S+/g, (t) => {
+			let i = n?.[t]?.[r];
+			if (!i) return t;
+			let a = Array.isArray(i) ? i : [i];
+			return t === e.type && r === "base" ? a.map((e) => `${t}--${e}`).join(" ") : t === e.type && r !== "base" ? a.map((e) => `${t}-${r}--${e}`).join(" ") : `${t} ${a.map((e) => `${t}--${e}`).join(" ")}`;
+		});
+		return o ? [r, `${a} ${o}`] : [r, a];
+	}));
+};
+//#endregion
+export { n as default };

package/dist/Element/helpers/pluginSelector.d.ts

@@ -0,0 +1,11 @@
+import { ComponentDefinition, ComponentPluginWithHOC, ElementLayout, InternalPropsSTG0 } from '@plitzi/sdk-shared';
+export type pluginSelectorProps = {
+    key?: string;
+    plitziElementLayout?: ElementLayout;
+    type: string;
+    internalProps: InternalPropsSTG0;
+    components: Partial<Record<string, ComponentPluginWithHOC>>;
+    plugins: Record<string, ComponentDefinition>;
+};
+declare const pluginSelector: ({ key, plitziElementLayout, type, internalProps: internalPropsProp, components, plugins }: pluginSelectorProps) => import("react/jsx-runtime").JSX.Element | undefined;
+export default pluginSelector;

package/dist/Element/helpers/pluginSelector.mjs

@@ -0,0 +1,35 @@
+import e from "../PluginRemote.mjs";
+import { get as t } from "@plitzi/plitzi-ui/helpers";
+import { jsx as n } from "react/jsx-runtime";
+//#region src/Element/helpers/pluginSelector.tsx
+var r = (e, t) => Object.values(e).find((e) => e.subPlugins.find((e) => e === t)), i = ({ type: e, plugins: n }) => {
+	let i = (e ? n[e] : void 0) ?? r(n, e);
+	if (!i) return;
+	let a = t(i, "assets", []).filter((e) => e.type === "script"), { scope: o } = i;
+	return {
+		url: a.find((e) => e.isMain)?.params.src ?? t(a, "0.params.src", ""),
+		scope: o
+	};
+}, a = ({ key: t, plitziElementLayout: r, type: a, internalProps: o, components: s, plugins: c }) => {
+	let l = {
+		...o,
+		plitziElementLayout: r
+	}, u = s.notFound ? /* @__PURE__ */ n(s.notFound, { internalProps: l }, t) : void 0;
+	if (!a) return u;
+	let d = s[a];
+	if (d) return /* @__PURE__ */ n(d, {
+		internalProps: l,
+		extraProps: d.extraProps
+	}, t);
+	let f = i({
+		type: a,
+		plugins: c
+	});
+	return f ? /* @__PURE__ */ n(e, {
+		url: f.url,
+		scope: f.scope,
+		internalProps: l
+	}, t) : u;
+};
+//#endregion
+export { a as default };

package/dist/Element/hocs/withElement.d.ts

@@ -0,0 +1,14 @@
+import { InternalPropsSTG1 } from '@plitzi/sdk-shared';
+import { FC, ReactNode } from 'react';
+export type WithElementProps<T> = {
+    plitziJsxSkipHOC?: boolean;
+    internalProps: InternalPropsSTG1;
+    className?: string;
+    children?: ReactNode;
+    extraProps?: Record<string, unknown>;
+} & T;
+declare const withElement: <T extends object>(WrappedComponent: FC<T>) => {
+    (props: WithElementProps<T>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default withElement;

package/dist/Element/hocs/withElement.mjs

@@ -0,0 +1,84 @@
+import e from "../hooks/useElementInternal.mjs";
+import t from "@plitzi/plitzi-ui/ErrorBoundary";
+import { omit as n } from "@plitzi/plitzi-ui/helpers/lodash";
+import { useMemo as r, useRef as i } from "react";
+import a from "@plitzi/sdk-event-bridge/hooks/useEventBridge";
+import o from "@plitzi/sdk-shared/elements/ElementContext";
+import s from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
+import { jsx as c } from "react/jsx-runtime";
+//#region src/Element/hocs/withElement.tsx
+var l = (l) => {
+	let u = (u) => {
+		let d = i(void 0), { id: f, rootId: p } = u.internalProps, m = r(() => ({
+			id: f,
+			rootId: p,
+			plitziJsxSkipHOC: !0
+		}), [f, p]);
+		if (u.plitziJsxSkipHOC) return r(() => /* @__PURE__ */ c(o, {
+			value: m,
+			children: /* @__PURE__ */ c(l, {
+				...u,
+				internalProps: u.internalProps
+			})
+		}), [m, u]);
+		let { settings: { previewMode: h }, root: { baseElementId: g } } = s(), { internalProps: _, customProps: v, children: y } = e({
+			internalProps: u.internalProps,
+			children: u.children,
+			previewMode: h,
+			baseElementId: g
+		}), { attributes: b, definition: x, style: S, plitziElementLayout: C, elementState: w, setElementState: T } = _;
+		a("element", r(() => ({ [`${f}_setState`]: T }), [f, T]));
+		let E = r(() => ({
+			id: f,
+			rootId: p,
+			attributes: b,
+			definition: x,
+			plitziElementLayout: C,
+			style: S,
+			elementState: w,
+			setElementState: T
+		}), [
+			b,
+			x,
+			w,
+			f,
+			C,
+			p,
+			S,
+			T
+		]);
+		return r(() => {
+			let e = {
+				..._.attributes,
+				...u.extraProps,
+				...v,
+				...n(u, [
+					"plitziJsxSkipHOC",
+					"internalProps",
+					"className",
+					"children",
+					"extraProps"
+				])
+			};
+			return y && (e = {
+				...e,
+				children: y
+			}), /* @__PURE__ */ c(t, { children: /* @__PURE__ */ c(o, {
+				value: E,
+				children: /* @__PURE__ */ c(l, {
+					...e,
+					ref: d
+				})
+			}) });
+		}, [
+			_.attributes,
+			u,
+			v,
+			y,
+			E
+		]);
+	};
+	return u.displayName = `withElement(${l.displayName || l.name})`, u;
+};
+//#endregion
+export { l as default };

package/dist/Element/hooks/useElementDataSource.d.ts

@@ -0,0 +1,9 @@
+import { ElementBinding, UseDataSourceFilter } from '@plitzi/sdk-shared';
+export type UseElementDataSourceProps = {
+    id: string;
+    bindings?: Record<string, ElementBinding[]>;
+    filterMode?: UseDataSourceFilter;
+    sources?: string[];
+};
+declare const useElementDataSource: ({ id, bindings, sources: sourcesProp, filterMode }: UseElementDataSourceProps) => Record<string, unknown>;
+export default useElementDataSource;

package/dist/Element/hooks/useElementDataSource.mjs

@@ -0,0 +1,15 @@
+import { useMemo as e } from "react";
+import t from "@plitzi/sdk-shared/dataSource/hooks/useDataSource";
+//#region src/Element/hooks/useElementDataSource.ts
+var n = ({ id: n, bindings: r, sources: i, filterMode: a }) => t({
+	id: n,
+	mode: "read",
+	sourceFilter: e(() => {
+		let e = new Set(i ?? []);
+		for (let t of Object.values(r ?? {})) if (Array.isArray(t)) for (let { source: n } of t) n && e.add(n);
+		return e.size > 0 && !e.has("variables") && e.add("variables"), [...e];
+	}, [r, i]),
+	filterMode: a
+});
+//#endregion
+export { n as default };

package/dist/Element/hooks/useElementInteractions.d.ts

@@ -0,0 +1,8 @@
+import { Element } from '@plitzi/sdk-shared';
+export type UseElementInteractionsProps = {
+    attributes: Element['attributes'];
+    definition: Element['definition'];
+    setElementState: <T extends Record<string, unknown> = Record<string, unknown>>(value?: T | ((prev: T) => T)) => boolean;
+};
+declare const useElementInteractions: ({ attributes, definition, setElementState }: UseElementInteractionsProps) => Record<string, import('@plitzi/sdk-shared').InteractionCallback>;
+export default useElementInteractions;

package/dist/Element/hooks/useElementInteractions.mjs

@@ -0,0 +1,41 @@
+import e from "../helpers/getInteractions.mjs";
+import { useCallback as t, useMemo as n, useRef as r } from "react";
+import { omit as i, set as a } from "@plitzi/plitzi-ui/helpers";
+import { produce as o } from "immer";
+//#region src/Element/hooks/useElementInteractions.ts
+var s = (e) => {
+	if (typeof e != "string") return e;
+	let t = e.toLowerCase();
+	return t === "true" || t === "false" || t === "yes" || t === "no" ? t === "true" || t === "yes" : e;
+}, c = ({ attributes: c, definition: l, setElementState: u }) => {
+	let d = r({}), f = t((e) => {
+		let t = d.current;
+		if (!e.key || !e.value) return {
+			prevState: t,
+			nextState: t
+		};
+		let { key: n } = e, { value: r } = e;
+		r = s(r);
+		let c = {};
+		return c = r === void 0 ? i(t, [n]) : o(t, (e) => a(e, n, r)), u(c) ? (d.current = c, {
+			prevState: t,
+			nextState: c
+		}) : {
+			prevState: t,
+			nextState: t
+		};
+	}, [u]), p = t((e, t) => {
+		let { revertOnFinish: n } = e;
+		if (!n || !t || !t.prevState) return;
+		let { prevState: r } = t;
+		d.current = r, u(r);
+	}, [u]);
+	return n(() => e(c, l, f, p), [
+		c,
+		l,
+		f,
+		p
+	]);
+};
+//#endregion
+export { c as default };

package/dist/Element/hooks/useElementInternal.d.ts

@@ -0,0 +1,48 @@
+import { InternalPropsSTG1 } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type UseElementInternalProps = {
+    children?: ReactNode;
+    internalProps: InternalPropsSTG1;
+    previewMode?: boolean;
+    baseElementId?: string;
+};
+declare const useElementInternal: ({ children, internalProps, previewMode, baseElementId }: UseElementInternalProps) => {
+    internalProps: {
+        setElementState: <T extends Record<string, unknown> = Record<string, unknown>>(value?: T | ((prev: T) => T)) => boolean;
+        rootId: string | undefined;
+        attributes: {
+            [x: string]: unknown;
+            subType?: string;
+        };
+        definition: import('@plitzi/sdk-shared').ElementDefinition;
+        elementState: {
+            [x: string]: unknown;
+            styleVariant?: Partial<Record<string, Partial<Record<string, string | string[]>>>>;
+            styleSelectors?: import('@plitzi/sdk-shared').ElementDefinition["styleSelectors"];
+            visibility?: boolean;
+        };
+        style: Record<string, string> | undefined;
+        id: string;
+        plitziElementLayout?: import('@plitzi/sdk-shared').ElementLayout;
+    };
+    customProps: Omit<{
+        setElementState: <T extends Record<string, unknown> = Record<string, unknown>>(value?: T | ((prev: T) => T)) => boolean;
+        rootId: string | undefined;
+        attributes: {
+            [x: string]: unknown;
+            subType?: string;
+        };
+        definition: import('@plitzi/sdk-shared').ElementDefinition;
+        elementState: {
+            [x: string]: unknown;
+            styleVariant?: Partial<Record<string, Partial<Record<string, string | string[]>>>>;
+            styleSelectors?: import('@plitzi/sdk-shared').ElementDefinition["styleSelectors"];
+            visibility?: boolean;
+        };
+        style: Record<string, string> | undefined;
+        id: string;
+        plitziElementLayout?: import('@plitzi/sdk-shared').ElementLayout;
+    }, "id" | "definition" | "attributes" | "style" | "rootId" | "plitziElementLayout" | "setElementState" | "elementState">;
+    children: ReactNode;
+};
+export default useElementInternal;

package/dist/Element/hooks/useElementInternal.mjs

@@ -0,0 +1,102 @@
+import e from "./useElementDataSource.mjs";
+import t from "./useElementState.mjs";
+import n from "./useInternalItems.mjs";
+import r from "../helpers/parseStyleSelectors.mjs";
+import { useMemo as i } from "react";
+import { get as a, omit as o } from "@plitzi/plitzi-ui/helpers";
+import s from "@plitzi/sdk-data-source/helpers/getBindingsDetails";
+import { hasValidToken as c, processTwig as l } from "@plitzi/sdk-shared/helpers/twigWrapper";
+import { createStoreHook as u } from "@plitzi/sdk-store/createStore";
+//#region src/Element/hooks/useElementInternal.ts
+var d = (e, t, n = {}, i = {}) => {
+	let u, { attributes: d, definition: f } = e, { rootId: p, plitziElementLayout: m } = t;
+	if (t.attributes && (d = {
+		...d,
+		...t.attributes
+	}), Object.keys(n).length > 0) {
+		let t = s(n, {
+			...e,
+			attributes: d
+		}, u);
+		({attributes: d, definition: f, style: u} = t);
+	}
+	let { variables: h } = n;
+	return h && Object.keys(h).length > 0 && (d = Object.keys(d).reduce((e, t) => typeof d[t] == "string" && c(d[t]) ? {
+		...e,
+		[t]: l(d[t], h, !0)
+	} : {
+		...e,
+		[t]: d[t]
+	}, {})), d = {
+		...d,
+		...o(i, ["visibility", "styleSelectors"])
+	}, f = {
+		...f,
+		styleSelectors: {
+			...f.styleSelectors,
+			...f.initialState?.styleSelectors,
+			...i.styleSelectors ?? {}
+		}
+	}, f.styleSelectors = r(f), {
+		...t,
+		rootId: a(m, "rootId", p),
+		attributes: {
+			...d,
+			...o(t, [
+				"id",
+				"rootId",
+				"attributes",
+				"definition",
+				"plitziElementLayout"
+			])
+		},
+		definition: f,
+		elementState: {
+			...f.initialState,
+			...i
+		},
+		style: u
+	};
+}, f = ({ children: r, internalProps: a, previewMode: s = !1, baseElementId: c }) => {
+	let { useStore: l } = u(), { id: f } = a, [p] = l(`schema.flat.${f}`);
+	if (!p) throw Error(`Element ${f} not found, Page ${c}`);
+	let { state: m, setElementState: h } = t({
+		bindings: p.definition.bindings,
+		previewMode: s
+	}), g = e({
+		id: f,
+		bindings: p.definition.bindings,
+		sources: ["variables"]
+	}), _ = i(() => ({
+		...d(p, a, g, m),
+		setElementState: h
+	}), [
+		p,
+		a,
+		g,
+		m,
+		h
+	]);
+	return {
+		internalProps: _,
+		customProps: o(_, [
+			"id",
+			"rootId",
+			"plitziElementLayout",
+			"attributes",
+			"definition",
+			"style",
+			"elementState",
+			"setElementState"
+		]),
+		children: n({
+			id: f,
+			definition: _.definition,
+			plitziElementLayout: _.plitziElementLayout,
+			children: r,
+			previewMode: s
+		})
+	};
+};
+//#endregion
+export { f as default };

package/dist/Element/hooks/useElementState.d.ts

@@ -0,0 +1,11 @@
+import { Element } from '@plitzi/sdk-shared';
+export type UseElementStateProps = {
+    bindings?: Partial<Element['definition']['bindings']>;
+    previewMode: boolean;
+};
+declare const useElementState: ({ bindings, previewMode }: UseElementStateProps) => {
+    state: Record<string, unknown>;
+    setState: import('react').Dispatch<import('react').SetStateAction<Record<string, unknown>>>;
+    setElementState: <T extends Record<string, unknown> = Record<string, unknown>>(value?: T | ((prev: T) => T)) => boolean;
+};
+export default useElementState;

package/dist/Element/hooks/useElementState.mjs

@@ -0,0 +1,23 @@
+import { useCallback as e, useMemo as t, useState as n } from "react";
+import { get as r, omit as i } from "@plitzi/plitzi-ui/helpers";
+//#region src/Element/hooks/useElementState.ts
+var a = ({ bindings: a, previewMode: o }) => {
+	let [s, c] = n({}), l = t(() => {
+		let e = a?.initialState && Array.isArray(a.initialState) ? a.initialState : [], t = a?.attributes && Array.isArray(a.attributes) ? a.attributes : [];
+		return {
+			stateBinded: e.filter((e) => e.enabled !== !1).map((e) => r(e, "toPath", "")),
+			attributesBinded: t.filter((e) => e.enabled !== !1).map((e) => r(e, "toPath", ""))
+		};
+	}, [a]);
+	return {
+		state: s,
+		setState: c,
+		setElementState: e((e) => o ? (c((t) => {
+			if (!e) return {};
+			let n = typeof e == "function" ? e(t) : e;
+			return l.attributesBinded.length && (n = i(n, l.attributesBinded)), n;
+		}), !0) : !1, [l, o])
+	};
+};
+//#endregion
+export { a as default };

package/dist/Element/hooks/useInternalClassName.d.ts

@@ -0,0 +1,12 @@
+import { Element, ElementLayout } from '@plitzi/sdk-shared';
+export type UseInternalClassNameProps = {
+    className?: string;
+    previewMode?: boolean;
+    baseElementId?: string;
+    id: string;
+    elementState: Record<string, unknown>;
+    definition: Element['definition'];
+    plitziElementLayout?: ElementLayout;
+};
+declare const useInternalClassName: ({ id, className, previewMode, baseElementId, plitziElementLayout, definition, elementState }: UseInternalClassNameProps) => string;
+export default useInternalClassName;

package/dist/Element/hooks/useInternalClassName.mjs

@@ -0,0 +1,26 @@
+import { useMemo as e } from "react";
+import t from "clsx";
+//#region src/Element/hooks/useInternalClassName.ts
+var n = ({ id: n, className: r, previewMode: i, baseElementId: a, plitziElementLayout: o, definition: s, elementState: c }) => {
+	let { items: l } = s, u = c.visibility;
+	return e(() => t(r, {
+		"plitzi-component--hidden": u === !1 || u === "false",
+		"plitzi-component": !i && !o,
+		"plitzi-component--layout": !i && !!o,
+		with__container: !i && !!l,
+		"container--empty": !i && !!l && l.length === 0 && !o,
+		"container--base-element": !i && !!l && a === n,
+		"plitzi-component--layout-body": o && n === o.containerId
+	}, s.styleSelectors.base), [
+		r,
+		u,
+		i,
+		o,
+		l,
+		a,
+		n,
+		s.styleSelectors.base
+	]);
+};
+//#endregion
+export { n as default };

package/dist/Element/hooks/useInternalItems.d.ts

@@ -0,0 +1,10 @@
+import { Element, ElementLayout } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+declare const useInternalItems: ({ id, definition, plitziElementLayout, children, previewMode }: {
+    id: string;
+    definition: Element["definition"];
+    plitziElementLayout?: ElementLayout;
+    children: ReactNode | ReactNode[];
+    previewMode?: boolean;
+}) => ReactNode;
+export default useInternalItems;