@plitzi/sdk-elements 0.37.1 → 0.37.3

package/dist/elements/provider/ApiContainer/declaration.mjs

@@ -1,8 +1,116 @@
-import { elementDeclaration as e } from "@plitzi/sdk-shared/authoring/declare";
+import { elementDeclaration as e, valuesOf as t } from "@plitzi/sdk-shared/authoring/declare";
 //#region src/elements/provider/ApiContainer/declaration.ts
-var t = e()({
+var n = e()({
 	type: "apiContainer",
+	attributeValues: {
+		subType: t()([
+			"",
+			"div",
+			"header",
+			"footer",
+			"nav",
+			"main",
+			"section",
+			"article",
+			"aside",
+			"address",
+			"figure"
+		]),
+		method: t()([
+			"get",
+			"post",
+			"put",
+			"delete",
+			"patch"
+		]),
+		credentials: t()([
+			"include",
+			"omit",
+			"same-origin"
+		]),
+		pagination: t()([
+			"none",
+			"url",
+			"append"
+		])
+	},
 	sourceType: "apiContainer",
+	triggers: {
+		onApiError: {
+			action: "onApiError",
+			title: "On Api Error",
+			type: "trigger",
+			params: {},
+			preview: {
+				url: "",
+				method: "",
+				status: "",
+				data: ""
+			}
+		},
+		onApiSuccess: {
+			action: "onApiSuccess",
+			title: "On Api Success",
+			type: "trigger",
+			params: {},
+			preview: {
+				url: "",
+				method: "",
+				status: "",
+				data: ""
+			}
+		}
+	},
+	callbacks: {
+		performQuery: {
+			action: "performQuery",
+			title: "Perform Query",
+			type: "callback",
+			preview: {},
+			params: { input: {
+				label: "Input (server providers)",
+				type: "codemirror-json",
+				defaultValue: "{}",
+				description: "Values handed to a server-driven provider with its request, beside the page’s own route and query params — a search, a filter. Kept for the pages it loads after (`loadMore`, `goToPage`) until the next query."
+			} }
+		},
+		loadMore: {
+			action: "loadMore",
+			title: "Load More",
+			type: "callback",
+			preview: {},
+			params: {}
+		},
+		goToPage: {
+			action: "goToPage",
+			title: "Go To Page",
+			type: "callback",
+			preview: {},
+			params: { page: {
+				label: "Page",
+				defaultValue: "1",
+				type: "text"
+			} }
+		},
+		writeRecord: {
+			action: "writeRecord",
+			title: "Write Record",
+			type: "callback",
+			preview: { action: "create" },
+			params: {
+				action: {
+					label: "Endpoint",
+					defaultValue: "create",
+					type: "text"
+				},
+				recordId: {
+					label: "Record Id",
+					defaultValue: "",
+					type: "text"
+				}
+			}
+		}
+	},
 	content: {
 		attributes: {
 			query: "",
@@ -26,7 +134,7 @@ var t = e()({
 		definition: {
 			label: "Api Container",
 			type: "apiContainer",
-			description: "Fetches data from a backend HTTP API (its `query`/`method`/`credentials`) and exposes the response as a data source ITS DESCENDANTS bind to (source `apiContainer_<id>.data`; only elements inside it can consume it). This is how you get backend data into the frontend. Its `mockData` prop is builder-only sample data — the published runtime fetches the real `query`, so always set a real query for production. With `cache: true` a browser request is kept for `staleTime` seconds (default 30) and shared with every provider asking the same thing; it is off unless set. A flow refreshes it with `performQuery` or the global `invalidateQueries` step. Its `subType` (container tag) is empty by default, and then it renders NO element of its own: its children lay out directly in its parent, and any class, variant or style binding on it applies to nothing. To style the provider itself give it a tag (`subType: \"div\"`, `section`, …); otherwise style its parent or a child.",
+			description: "Fetches data from a backend HTTP API (its `query`/`method`/`credentials`) and exposes the response as a data source ITS DESCENDANTS bind to (source `apiContainer_<id>.data`; only elements inside it can consume it). This is how you get backend data into the frontend. Its `mockData` prop is builder-only sample data — the published runtime fetches the real `query`, so always set a real query for production. With `cache: true` a browser request is kept for `staleTime` seconds (default 30) and shared with every provider asking the same thing; it is off unless set. A flow refreshes it with `performQuery` or the global `invalidateQueries` step, and `refreshSeconds` makes it ask again on its own every N seconds (either runtime; paused while the tab is hidden) — the way to keep a queue, feed or status board current without a plugin. Its `subType` (container tag) is empty by default, and then it renders NO element of its own: its children lay out directly in its parent, and any class, variant or style binding on it applies to nothing. To style the provider itself give it a tag (`subType: \"div\"`, `section`, …); otherwise style its parent or a child.",
 			items: [],
 			bindings: {},
 			styleSelectors: { base: "" },
@@ -60,4 +168,4 @@ var t = e()({
 	}
 });
 //#endregion
-export { t as default };
+export { n as default };

package/dist/elements/provider/ApiContainer/helpers/isEmptyAnswer.d.ts

@@ -0,0 +1,16 @@
+type ProviderSlice = {
+    records?: unknown[];
+    record?: unknown;
+    data?: unknown;
+};
+/**
+ * Whether a provider has nothing to show, for each shape of answer it can hold.
+ *
+ * A connector list publishes `records`, a detail provider `record`, and a plain `query` the body it received under
+ * `data`. Only the first two used to be asked, so a `query` — whose slice has no `records` at all — reported empty
+ * whatever it held, and an empty state bound to `isEmpty` showed over a full page.
+ *
+ * `records` is the list after pagination has accumulated it, which is why it is passed in rather than read here.
+ */
+export declare const isEmptyAnswer: (slice: ProviderSlice, records: unknown[], singleRecord: boolean) => boolean;
+export {};

package/dist/elements/provider/ApiContainer/helpers/isEmptyAnswer.mjs

@@ -0,0 +1,4 @@
+//#region src/elements/provider/ApiContainer/helpers/isEmptyAnswer.ts
+var e = (e) => e == null || e === "" || Array.isArray(e) && e.length === 0 || typeof e == "object" && !Array.isArray(e) && Object.keys(e).length === 0, t = (t, n, r) => r ? t.record === void 0 : Array.isArray(t.records) ? n.length === 0 : e(t.data);
+//#endregion
+export { t as isEmptyAnswer };

package/dist/elements/provider/ApiContainer/helpers/providerOutcome.d.ts

@@ -0,0 +1,25 @@
+export type ProviderOutcome = 'success' | 'error' | undefined;
+export type ProviderOutcomeParams = {
+    serverMode: boolean;
+    /** Browser provider: what its request answered. */
+    isSuccess: boolean;
+    isError: boolean;
+    /** Server provider: a payload has arrived, and it is for the page the visitor is on. */
+    rscResolved: boolean;
+    rscPending: boolean;
+    /** Server provider: this element's slice of that payload — `null` when the server could not resolve it. */
+    elementData: unknown;
+};
+/**
+ * Which of `onApiSuccess` / `onApiError` a provider has earned, or neither yet.
+ *
+ * The same question for both runtimes, answered from what each one has. A browser provider has its request's
+ * status. A server provider has no request of its own — its data arrives in the page's RSC payload — so success is
+ * its slice being there and error is the payload arriving WITHOUT it. Asked only of the browser request, a server
+ * provider never fired either trigger, and a flow its author wired to them never ran.
+ *
+ * A payload resolved for another page is neither: the visitor navigated and this provider's answer is still on its
+ * way.
+ */
+declare const providerOutcome: ({ serverMode, isSuccess, isError, rscResolved, rscPending, elementData }: ProviderOutcomeParams) => ProviderOutcome;
+export default providerOutcome;

package/dist/elements/provider/ApiContainer/helpers/providerOutcome.mjs

@@ -0,0 +1,7 @@
+//#region src/elements/provider/ApiContainer/helpers/providerOutcome.ts
+var e = ({ serverMode: e, isSuccess: t, isError: n, rscResolved: r, rscPending: i, elementData: a }) => {
+	if (!e) return t ? "success" : n ? "error" : void 0;
+	if (r && !i) return a == null ? "error" : "success";
+};
+//#endregion
+export { e as default };

package/dist/elements/provider/ApiContainer/helpers/queryInput.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A query's `input`, as the server reads a page's query params: flat, each value a string. An object as authored, or
+ * its JSON text as the editor keeps it; anything else is no input at all.
+ */
+export declare const queryInputOf: (input: unknown) => Record<string, string> | undefined;

package/dist/elements/provider/ApiContainer/helpers/queryInput.mjs

@@ -0,0 +1,12 @@
+//#region src/elements/provider/ApiContainer/helpers/queryInput.ts
+var e = (e) => {
+	let t = e;
+	if (typeof t == "string") try {
+		t = JSON.parse(t || "{}");
+	} catch {
+		return;
+	}
+	if (typeof t == "object" && t && !Array.isArray(t)) return Object.fromEntries(Object.entries(t).flatMap(([e, t]) => typeof t == "string" || typeof t == "number" || typeof t == "boolean" ? [[e, String(t)]] : []));
+};
+//#endregion
+export { e as queryInputOf };

package/dist/elements/provider/ApiContainer/hooks/useAutoRefresh.d.ts

@@ -0,0 +1,21 @@
+export type UseAutoRefreshParams = {
+    /** Seconds between refreshes. Zero, a negative number or anything that is not a number turns it off. */
+    seconds: number | string;
+    /** Whether there is anything to refresh at all — a provider that cannot fetch must not be asked to. */
+    enabled: boolean;
+    refresh: () => unknown;
+};
+/**
+ * Asks a provider for its data again every `seconds`, for a page that shows something still moving.
+ *
+ * Three things a bare `setInterval` gets wrong, each of them a load the page's server pays for:
+ *
+ * - **A hidden tab does not ask.** Nobody is looking, and a dashboard left open in a background tab overnight is
+ *   otherwise thousands of requests answering no one.
+ * - **One at a time.** A refresh that outlives the interval is not joined by a second one — on a slow server that
+ *   is how a poll turns into a pile-up.
+ * - **The newest `refresh`, without restarting the clock.** The callback is read through a ref, so a re-render that
+ *   hands over a new function does not reset the countdown to the full interval each time.
+ */
+declare const useAutoRefresh: ({ seconds, enabled, refresh }: UseAutoRefreshParams) => void;
+export default useAutoRefresh;

package/dist/elements/provider/ApiContainer/hooks/useAutoRefresh.mjs

@@ -0,0 +1,18 @@
+import { useEffect as e, useRef as t } from "react";
+//#region src/elements/provider/ApiContainer/hooks/useAutoRefresh.ts
+var n = ({ seconds: n, enabled: r, refresh: i }) => {
+	let a = t(i);
+	a.current = i;
+	let o = Number(n), s = r && Number.isFinite(o) && o > 0;
+	e(() => {
+		if (!s) return;
+		let e = !1, t = setInterval(() => {
+			e || document.visibilityState === "hidden" || (e = !0, Promise.resolve().then(() => a.current()).catch(() => void 0).finally(() => {
+				e = !1;
+			}));
+		}, o * 1e3);
+		return () => clearInterval(t);
+	}, [s, o]);
+};
+//#endregion
+export { n as default };

package/dist/elements/provider/ApiContainer/index.d.ts

@@ -1,9 +1,97 @@
 declare const ApiContainer: {
-    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./ApiContainer').ApiContainerProps>): import("react").JSX.Element;
+    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./ApiContainer').ApiContainerProps>): import('react').JSX.Element;
     displayName: string;
 } & {
     readonly type: "apiContainer";
+    readonly attributeValues: {
+        readonly subType: readonly string[];
+        readonly method: readonly string[];
+        readonly credentials: readonly string[];
+        readonly pagination: readonly string[];
+    };
     readonly sourceType: "apiContainer";
+    readonly triggers: {
+        readonly onApiError: {
+            readonly action: "onApiError";
+            readonly title: "On Api Error";
+            readonly type: "trigger";
+            readonly params: {};
+            readonly preview: {
+                readonly url: "";
+                readonly method: "";
+                readonly status: "";
+                readonly data: "";
+            };
+        };
+        readonly onApiSuccess: {
+            readonly action: "onApiSuccess";
+            readonly title: "On Api Success";
+            readonly type: "trigger";
+            readonly params: {};
+            readonly preview: {
+                readonly url: "";
+                readonly method: "";
+                readonly status: "";
+                readonly data: "";
+            };
+        };
+    };
+    readonly callbacks: {
+        readonly performQuery: {
+            readonly action: "performQuery";
+            readonly title: "Perform Query";
+            readonly type: "callback";
+            readonly preview: {};
+            readonly params: {
+                readonly input: {
+                    readonly label: "Input (server providers)";
+                    readonly type: "codemirror-json";
+                    readonly defaultValue: "{}";
+                    readonly description: string;
+                };
+            };
+        };
+        readonly loadMore: {
+            readonly action: "loadMore";
+            readonly title: "Load More";
+            readonly type: "callback";
+            readonly preview: {};
+            readonly params: {};
+        };
+        readonly goToPage: {
+            readonly action: "goToPage";
+            readonly title: "Go To Page";
+            readonly type: "callback";
+            readonly preview: {};
+            readonly params: {
+                readonly page: {
+                    readonly label: "Page";
+                    readonly defaultValue: "1";
+                    readonly type: "text";
+                };
+            };
+        };
+        readonly writeRecord: {
+            readonly action: "writeRecord";
+            readonly title: "Write Record";
+            readonly type: "callback";
+            readonly preview: {
+                readonly action: "create";
+            };
+            readonly params: {
+                readonly action: {
+                    readonly label: "Endpoint";
+                    readonly defaultValue: "create";
+                    readonly type: "text";
+                };
+                readonly recordId: {
+                    readonly label: "Record Id";
+                    readonly defaultValue: "";
+                    readonly type: "text";
+                };
+            };
+        };
+    };
     readonly content: {
         readonly attributes: {
             readonly query: "";

package/dist/elements/provider/Channel/Channel.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode, RefObject } from 'react';
+export type ChannelProps = {
+    ref?: RefObject<HTMLElement | null>;
+    className?: string;
+    children?: ReactNode;
+    /** The topic, usually a template: `board:{{ id }}`. A channel the space declares must cover it. */
+    topic?: string;
+    /**
+     * What opens a topic of a private (`grant: true`) channel: bound to the `grant` the action that let this visitor in
+     * returned — `{{ data.grant }}`. Empty for any other channel.
+     */
+    grant?: string;
+    /** What this page announces to the members — an object from a binding, or JSON text typed in the builder. */
+    presence?: unknown;
+    /** How many of the latest messages its source holds. */
+    keep?: number | string;
+    /** Empty renders no element of its own, as a provider does; a tag gives it one to style. */
+    subType?: '' | 'div' | 'section' | 'aside' | 'main';
+};
+declare const Channel: ({ ref, className, children, topic, grant, presence, keep, subType }: ChannelProps) => import('react').JSX.Element;
+declare const _default: {
+    (props: import('../../../Element/hocs/withElement').WithElementProps<ChannelProps>): import('react').JSX.Element;
+    displayName: string;
+};
+export default _default;
+export { Channel };

package/dist/elements/provider/Channel/Channel.mjs

@@ -0,0 +1,92 @@
+import e from "../../../Element/hocs/withElement.mjs";
+import t from "../../../Element/hooks/useElement.mjs";
+import { RootElement as n } from "../../../Element/RootElement.mjs";
+import r from "../../../dataSource/pathFields.mjs";
+import i from "./declaration.mjs";
+import a from "../../../realtime/useChannel.mjs";
+import { use as o, useCallback as s, useMemo as c, useState as l } from "react";
+import u from "@plitzi/sdk-shared/hooks/usePlitziServiceContext";
+import { StoreProvider as d } from "@plitzi/nexus/react";
+import { emptyObject as f } from "@plitzi/sdk-shared/helpers/utils";
+import { jsx as p } from "react/jsx-runtime";
+import m from "clsx";
+import h from "@plitzi/sdk-shared/dataSource/helpers/getSourceName";
+import g from "@plitzi/sdk-shared/dataSource/hooks/useRegisterSource";
+import { JOIN_TYPE as _, LEAVE_TYPE as v, PRESENCE_TYPE as y } from "@plitzi/sdk-shared/realtime";
+//#region src/elements/provider/Channel/Channel.tsx
+var b = (e) => {
+	if (typeof e != "string") return e;
+	try {
+		return JSON.parse(e);
+	} catch {
+		return e;
+	}
+}, x = /* @__PURE__ */ new Set([
+	y,
+	_,
+	v
+]), S = ({ ref: e, className: _, children: v, topic: y = "", grant: S = "", presence: C, keep: w = 20, subType: T = "" }) => {
+	let { id: E, definition: { label: D = "Channel" } } = t(), { settings: { previewMode: O }, contexts: { InteractionsContext: k } } = u(), { interactionsManager: A } = o(k), j = Math.max(0, Number(w) || 0), [M, N] = l([]), P = s((e) => {
+		x.has(e.type) || (j > 0 && N((t) => [...t, e].slice(-j)), A.interactionTrigger(E, "onMessage", { ...e }));
+	}, [
+		E,
+		A,
+		j
+	]), F = s(({ from: e, user: t, state: n }) => void A.interactionTrigger(E, "onJoin", {
+		from: e,
+		user: t ?? "",
+		state: n
+	}), [E, A]), I = s(({ from: e, user: t, state: n }) => void A.interactionTrigger(E, "onLeave", {
+		from: e,
+		user: t ?? "",
+		state: n
+	}), [E, A]), L = a(O && y ? y : void 0, {
+		grant: S || void 0,
+		presence: C === void 0 || C === "" ? void 0 : b(C),
+		onMessage: P,
+		onJoin: F,
+		onLeave: I
+	}), R = c(() => ({
+		publish: {
+			...i.callbacks.publish,
+			callback: ({ type: e, data: t }) => typeof e == "string" && e ? L.publish(e, b(t)) : Promise.resolve(!1)
+		},
+		setPresence: {
+			...i.callbacks.setPresence,
+			callback: ({ data: e }) => L.setPresence(b(e))
+		}
+	}), [L]), z = h(i.sourceType, E), B = c(() => ({
+		connected: L.connected,
+		me: L.me ?? "",
+		members: L.members,
+		messages: M,
+		last: M.at(-1) ?? null
+	}), [
+		L.connected,
+		L.me,
+		L.members,
+		M
+	]), V = s(() => r(B), [B]);
+	g({
+		id: E,
+		source: z,
+		name: D || `Channel - ${E}`,
+		fields: V
+	});
+	let H = c(() => z ? { runtime: { sources: { [z]: B } } } : f, [B, z]);
+	return /* @__PURE__ */ p(n, {
+		ref: e,
+		tag: T,
+		className: m("plitzi-component__channel", _),
+		interactionTriggers: i.triggers,
+		interactionCallbacks: R,
+		children: /* @__PURE__ */ p(d, {
+			inherit: "live",
+			name: `Channel:${E}`,
+			value: H,
+			children: v
+		})
+	});
+}, C = e(S);
+//#endregion
+export { S as Channel, C as default };

package/dist/elements/provider/Channel/Settings.d.ts

@@ -0,0 +1,9 @@
+type SettingsProps = {
+    topic?: string;
+    grant?: string;
+    keep?: number | string;
+    presence?: unknown;
+    onUpdate?: (key: string, value: string | boolean | number) => void;
+};
+declare const Settings: ({ topic, grant, keep, presence, onUpdate }: SettingsProps) => import('react').JSX.Element;
+export default Settings;

package/dist/elements/provider/Channel/Settings.mjs

@@ -0,0 +1,38 @@
+import { useCallback as e } from "react";
+import { jsx as t, jsxs as n } from "react/jsx-runtime";
+import r from "@plitzi/plitzi-ui/Input";
+import i from "@plitzi/plitzi-ui/TextArea";
+//#region src/elements/provider/Channel/Settings.tsx
+var a = (e) => typeof e == "string" ? e : e === void 0 ? "" : JSON.stringify(e, null, 2), o = ({ topic: o = "", grant: s = "", keep: c = 20, presence: l, onUpdate: u }) => {
+	let d = e((e) => u?.("topic", e), [u]), f = e((e) => u?.("grant", e), [u]), p = e((e) => u?.("keep", Number(e) || 0), [u]), m = e((e) => u?.("presence", e), [u]);
+	return /* @__PURE__ */ n("div", {
+		className: "flex h-full flex-col gap-4 py-2",
+		children: [
+			/* @__PURE__ */ t(r, {
+				value: o,
+				label: "Topic (e.g. board:{{ id }})",
+				onChange: d,
+				size: "sm"
+			}),
+			/* @__PURE__ */ t(r, {
+				value: s,
+				label: "Grant (private channels: the grant the action returned)",
+				onChange: f,
+				size: "sm"
+			}),
+			/* @__PURE__ */ t(r, {
+				value: String(c),
+				label: "Messages kept",
+				onChange: p,
+				size: "sm"
+			}),
+			/* @__PURE__ */ t(i, {
+				value: a(l),
+				label: "Presence (JSON)",
+				onChange: m
+			})
+		]
+	});
+};
+//#endregion
+export { o as default };

package/dist/elements/provider/Channel/declaration.d.ts

@@ -0,0 +1,138 @@
+import { ChannelProps } from './Channel';
+import { AuthorableAttributes } from '@plitzi/sdk-shared/authoring/declare';
+/** What this element can be authored with — its component's own props, minus what the runtime supplies. */
+export type ChannelAttributes = AuthorableAttributes<ChannelProps>;
+declare const declaration: {
+    readonly type: "channel";
+    readonly attributeValues: {
+        readonly subType: readonly string[];
+    };
+    readonly sourceType: "channel";
+    readonly triggers: {
+        readonly onMessage: {
+            readonly action: "onMessage";
+            readonly title: "On Message";
+            readonly type: "trigger";
+            readonly params: {};
+            readonly preview: {
+                readonly type: "";
+                readonly data: "";
+                readonly from: "";
+                readonly user: "";
+                readonly at: "";
+            };
+        };
+        readonly onJoin: {
+            readonly action: "onJoin";
+            readonly title: "On Join";
+            readonly type: "trigger";
+            readonly params: {};
+            readonly preview: {
+                readonly from: "";
+                readonly user: "";
+                readonly state: {};
+            };
+        };
+        readonly onLeave: {
+            readonly action: "onLeave";
+            readonly title: "On Leave";
+            readonly type: "trigger";
+            readonly params: {};
+            readonly preview: {
+                readonly from: "";
+                readonly user: "";
+                readonly state: {};
+            };
+        };
+    };
+    readonly callbacks: {
+        readonly publish: {
+            readonly action: "publish";
+            readonly title: "Publish";
+            readonly type: "callback";
+            readonly preview: {};
+            readonly params: {
+                readonly type: {
+                    readonly label: "Type";
+                    readonly defaultValue: "";
+                    readonly type: "text";
+                };
+                readonly data: {
+                    readonly label: "Data (JSON or a template)";
+                    readonly defaultValue: "";
+                    readonly type: "text";
+                };
+            };
+        };
+        readonly setPresence: {
+            readonly action: "setPresence";
+            readonly title: "Set Presence";
+            readonly type: "callback";
+            readonly preview: {};
+            readonly params: {
+                readonly data: {
+                    readonly label: "State (JSON or a template)";
+                    readonly defaultValue: "";
+                    readonly type: "text";
+                };
+            };
+        };
+    };
+    readonly content: {
+        readonly attributes: {
+            readonly topic: "";
+            readonly grant: "";
+            readonly keep: 20;
+            readonly subType: "";
+        };
+        readonly definition: {
+            readonly label: "Channel";
+            readonly type: "channel";
+            readonly description: string;
+            readonly items: readonly [];
+            readonly bindings: {};
+            readonly styleSelectors: {
+                readonly base: "";
+            };
+            readonly initialState: {
+                readonly visibility: true;
+            };
+        };
+        readonly builder: {
+            readonly canDelete: true;
+            readonly canSelect: true;
+            readonly canDragDrop: true;
+            readonly canMove: true;
+            readonly canTemplate: true;
+            readonly itemsAllowed: readonly [];
+            readonly itemsNotAllowed: readonly [];
+        };
+        readonly market: {
+            readonly category: "provider";
+            readonly owner: "Plitzi";
+            readonly verified: true;
+            readonly license: "MIT";
+            readonly website: "https://plitzi.com";
+            readonly backgroundColor: "#4422ee";
+            readonly icon: "fa-solid fa-tower-broadcast";
+        };
+        readonly defaultStyle: {
+            readonly name: "Channel";
+            readonly displayMode: "desktop";
+            readonly style: {
+                readonly base: {
+                    readonly default: {};
+                };
+            };
+            readonly subTypes: {};
+        };
+        readonly settings: {};
+    };
+} & import('@plitzi/sdk-shared/authoring/declare').ElementAttributesBrand<Partial<{
+    subType?: "" | "div" | "section" | "aside" | "main" | undefined;
+    topic?: string | undefined;
+    grant?: string | undefined;
+    presence?: unknown;
+    keep?: number | string | undefined;
+}>>;
+export default declaration;