@plitzi/sdk-elements 0.37.1 → 0.37.2

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/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,84 @@
 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 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 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/structure/Container/Container.d.ts

@@ -5,9 +5,9 @@ export type ContainerProps = {
     subType?: 'div' | 'header' | 'footer' | 'nav' | 'main' | 'section' | 'article' | 'aside' | 'address' | 'figure' | 'dl' | 'dt' | 'dd' | 'li';
     children?: ReactNode;
 };
-declare const Container: ({ ref, className, subType, children }: ContainerProps) => import("react").JSX.Element;
+declare const Container: ({ ref, className, subType, children }: ContainerProps) => import('react').JSX.Element;
 declare const _default: {
-    (props: import('../../../Element/hocs/withElement').WithElementProps<ContainerProps>): import("react").JSX.Element;
+    (props: import('../../../Element/hocs/withElement').WithElementProps<ContainerProps>): import('react').JSX.Element;
     displayName: string;
 };
 export default _default;

package/dist/elements/structure/Container/Settings.d.ts

@@ -2,5 +2,5 @@ type SettingsProps = {
     subType?: 'div' | 'header' | 'footer' | 'nav' | 'main' | 'section' | 'article' | 'aside' | 'address' | 'figure' | 'dl' | 'dt' | 'dd' | 'li';
     onUpdate?: (key: string, value: string | boolean | number) => void;
 };
-declare const Settings: ({ subType, onUpdate }: SettingsProps) => import("react").JSX.Element;
+declare const Settings: ({ subType, onUpdate }: SettingsProps) => import('react').JSX.Element;
 export default Settings;

package/dist/elements/structure/Container/index.d.ts

@@ -1,5 +1,5 @@
 declare const Container: {
-    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./Container').ContainerProps>): import("react").JSX.Element;
+    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./Container').ContainerProps>): import('react').JSX.Element;
     displayName: string;
 } & {
     readonly type: "container";

package/dist/elements/structure/DialogContainer/DialogContainer.d.ts

@@ -9,9 +9,9 @@ export type DialogContainerProps = {
     rejectButtonLabel: string;
     autoHideAfterClick: boolean;
 };
-declare const DialogContainer: ({ ref, className, children, headerLabel, acceptButtonLabel, acceptButtonLabelLoading, rejectButtonLabel, autoHideAfterClick }: DialogContainerProps) => import("react").JSX.Element;
+declare const DialogContainer: ({ ref, className, children, headerLabel, acceptButtonLabel, acceptButtonLabelLoading, rejectButtonLabel, autoHideAfterClick }: DialogContainerProps) => import('react').JSX.Element;
 declare const _default: {
-    (props: import('../../../Element/hocs/withElement').WithElementProps<DialogContainerProps>): import("react").JSX.Element;
+    (props: import('../../../Element/hocs/withElement').WithElementProps<DialogContainerProps>): import('react').JSX.Element;
     displayName: string;
 };
 export default _default;

package/dist/elements/structure/DialogContainer/DialogContainer.mjs

@@ -70,65 +70,15 @@ var v = ({ ref: e, className: v = "", children: y, headerLabel: b = "Dialog Head
 		N,
 		E
 	]), H = c(() => ({
-		onDialogAccept: {
-			action: "onDialogAccept",
-			title: "On Dialog Accept",
-			type: "trigger",
-			params: { metadata: {
-				type: "text",
-				defaultValue: ""
-			} },
-			preview: { metadata: "" }
-		},
-		onDialogReject: {
-			action: "onDialogReject",
-			title: "On Dialog Reject",
-			type: "trigger",
-			params: { metadata: {
-				type: "text",
-				defaultValue: ""
-			} },
-			preview: { metadata: "" }
-		},
-		onDialogOpen: {
-			action: "onDialogOpen",
-			title: "On Dialog Open",
-			type: "trigger",
-			params: { metadata: {
-				type: "text",
-				defaultValue: ""
-			} },
-			preview: { metadata: "" }
-		},
-		onDialogClose: {
-			action: "onDialogClose",
-			title: "On Dialog Close",
-			type: "trigger",
-			params: { metadata: {
-				type: "text",
-				defaultValue: ""
-			} },
-			preview: { metadata: "" }
-		}
-	}), []), U = c(() => ({
 		openDialog: {
-			action: "openDialog",
+			...i.callbacks.openDialog,
 			title: `Open ${O}`,
-			type: "callback",
-			callback: L,
-			params: { metadata: {
-				type: "text",
-				defaultValue: ""
-			} },
-			preview: { metadata: "" }
+			callback: L
 		},
 		closeDialog: {
-			action: "closeDialog",
+			...i.callbacks.closeDialog,
 			title: `Close ${O}`,
-			type: "callback",
-			callback: R,
-			preview: {},
-			params: {}
+			callback: R
 		}
 	}), [
 		R,
@@ -143,19 +93,19 @@ var v = ({ ref: e, className: v = "", children: y, headerLabel: b = "Dialog Head
 		N,
 		k.visibility
 	]);
-	let W = o(() => r(N), [N]);
+	let U = o(() => r(N), [N]);
 	_({
 		id: T,
 		source: A,
 		name: O || `Dialog - ${T}`,
-		fields: W
+		fields: U
 	});
-	let G = c(() => A ? { runtime: { sources: { [A]: N } } } : f, [A, N]);
+	let W = c(() => A ? { runtime: { sources: { [A]: N } } } : f, [A, N]);
 	return /* @__PURE__ */ m(n, {
 		ref: e,
 		className: h("plitzi-component__dialog-container", v),
-		interactionTriggers: H,
-		interactionCallbacks: U,
+		interactionTriggers: i.triggers,
+		interactionCallbacks: H,
 		children: [/* @__PURE__ */ p("div", {
 			className: h("dialog-container__background", D.backgroundContainer),
 			onClick: z
@@ -178,7 +128,7 @@ var v = ({ ref: e, className: v = "", children: y, headerLabel: b = "Dialog Head
 					children: /* @__PURE__ */ p(d, {
 						inherit: "live",
 						name: `Dialog:${T}`,
-						value: G,
+						value: W,
 						children: y
 					})
 				}),

package/dist/elements/structure/DialogContainer/Settings.d.ts

@@ -6,5 +6,5 @@ type SettingsProps = {
     autoHideAfterClick?: boolean;
     onUpdate?: (key: string, value: string | boolean | number) => void;
 };
-declare const Settings: ({ acceptButtonLabel, acceptButtonLabelLoading, rejectButtonLabel, headerLabel, autoHideAfterClick, onUpdate }: SettingsProps) => import("react").JSX.Element;
+declare const Settings: ({ acceptButtonLabel, acceptButtonLabelLoading, rejectButtonLabel, headerLabel, autoHideAfterClick, onUpdate }: SettingsProps) => import('react').JSX.Element;
 export default Settings;

package/dist/elements/structure/DialogContainer/declaration.d.ts

@@ -5,6 +5,87 @@ export type DialogContainerAttributes = AuthorableAttributes<DialogContainerProp
 declare const declaration: {
     readonly type: "dialogContainer";
     readonly sourceType: "dialogContainer";
+    readonly triggers: {
+        readonly onDialogAccept: {
+            readonly action: "onDialogAccept";
+            readonly title: "On Dialog Accept";
+            readonly type: "trigger";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+        readonly onDialogReject: {
+            readonly action: "onDialogReject";
+            readonly title: "On Dialog Reject";
+            readonly type: "trigger";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+        readonly onDialogOpen: {
+            readonly action: "onDialogOpen";
+            readonly title: "On Dialog Open";
+            readonly type: "trigger";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+        readonly onDialogClose: {
+            readonly action: "onDialogClose";
+            readonly title: "On Dialog Close";
+            readonly type: "trigger";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+    };
+    readonly callbacks: {
+        readonly openDialog: {
+            readonly action: "openDialog";
+            readonly title: "Open Dialog";
+            readonly type: "callback";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+        readonly closeDialog: {
+            readonly action: "closeDialog";
+            readonly title: "Close Dialog";
+            readonly type: "callback";
+            readonly preview: {};
+            readonly params: {};
+        };
+    };
     readonly content: {
         readonly attributes: {
             readonly headerLabel: "Dialog Header";
@@ -86,7 +167,7 @@ declare const declaration: {
                         readonly left: "50%";
                         readonly width: "500px";
                         readonly height: "300px";
-                        readonly 'background-color': "white";
+                        readonly 'background-color': "light-dark(white, oklch(0.21 0.006 285.885))";
                         readonly transform: "translate3d(-50%, -50%, 0px)";
                         readonly 'padding-top': "20px";
                         readonly 'padding-bottom': "20px";

package/dist/elements/structure/DialogContainer/declaration.mjs

@@ -3,6 +3,67 @@ import { elementDeclaration as e } from "@plitzi/sdk-shared/authoring/declare";
 var t = e()({
 	type: "dialogContainer",
 	sourceType: "dialogContainer",
+	triggers: {
+		onDialogAccept: {
+			action: "onDialogAccept",
+			title: "On Dialog Accept",
+			type: "trigger",
+			params: { metadata: {
+				type: "text",
+				defaultValue: ""
+			} },
+			preview: { metadata: "" }
+		},
+		onDialogReject: {
+			action: "onDialogReject",
+			title: "On Dialog Reject",
+			type: "trigger",
+			params: { metadata: {
+				type: "text",
+				defaultValue: ""
+			} },
+			preview: { metadata: "" }
+		},
+		onDialogOpen: {
+			action: "onDialogOpen",
+			title: "On Dialog Open",
+			type: "trigger",
+			params: { metadata: {
+				type: "text",
+				defaultValue: ""
+			} },
+			preview: { metadata: "" }
+		},
+		onDialogClose: {
+			action: "onDialogClose",
+			title: "On Dialog Close",
+			type: "trigger",
+			params: { metadata: {
+				type: "text",
+				defaultValue: ""
+			} },
+			preview: { metadata: "" }
+		}
+	},
+	callbacks: {
+		openDialog: {
+			action: "openDialog",
+			title: "Open Dialog",
+			type: "callback",
+			params: { metadata: {
+				type: "text",
+				defaultValue: ""
+			} },
+			preview: { metadata: "" }
+		},
+		closeDialog: {
+			action: "closeDialog",
+			title: "Close Dialog",
+			type: "callback",
+			preview: {},
+			params: {}
+		}
+	},
 	content: {
 		attributes: {
 			headerLabel: "Dialog Header",
@@ -77,7 +138,7 @@ var t = e()({
 					left: "50%",
 					width: "500px",
 					height: "300px",
-					"background-color": "white",
+					"background-color": "light-dark(white, oklch(0.21 0.006 285.885))",
 					transform: "translate3d(-50%, -50%, 0px)",
 					"padding-top": "20px",
 					"padding-bottom": "20px",

package/dist/elements/structure/DialogContainer/index.d.ts

@@ -1,9 +1,90 @@
 declare const DialogContainer: {
-    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./DialogContainer').DialogContainerProps>): import("react").JSX.Element;
+    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./DialogContainer').DialogContainerProps>): import('react').JSX.Element;
     displayName: string;
 } & {
     readonly type: "dialogContainer";
     readonly sourceType: "dialogContainer";
+    readonly triggers: {
+        readonly onDialogAccept: {
+            readonly action: "onDialogAccept";
+            readonly title: "On Dialog Accept";
+            readonly type: "trigger";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+        readonly onDialogReject: {
+            readonly action: "onDialogReject";
+            readonly title: "On Dialog Reject";
+            readonly type: "trigger";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+        readonly onDialogOpen: {
+            readonly action: "onDialogOpen";
+            readonly title: "On Dialog Open";
+            readonly type: "trigger";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+        readonly onDialogClose: {
+            readonly action: "onDialogClose";
+            readonly title: "On Dialog Close";
+            readonly type: "trigger";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+    };
+    readonly callbacks: {
+        readonly openDialog: {
+            readonly action: "openDialog";
+            readonly title: "Open Dialog";
+            readonly type: "callback";
+            readonly params: {
+                readonly metadata: {
+                    readonly type: "text";
+                    readonly defaultValue: "";
+                };
+            };
+            readonly preview: {
+                readonly metadata: "";
+            };
+        };
+        readonly closeDialog: {
+            readonly action: "closeDialog";
+            readonly title: "Close Dialog";
+            readonly type: "callback";
+            readonly preview: {};
+            readonly params: {};
+        };
+    };
     readonly content: {
         readonly attributes: {
             readonly headerLabel: "Dialog Header";
@@ -85,7 +166,7 @@ declare const DialogContainer: {
                         readonly left: "50%";
                         readonly width: "500px";
                         readonly height: "300px";
-                        readonly 'background-color': "white";
+                        readonly 'background-color': "light-dark(white, oklch(0.21 0.006 285.885))";
                         readonly transform: "translate3d(-50%, -50%, 0px)";
                         readonly 'padding-top': "20px";
                         readonly 'padding-bottom': "20px";

package/dist/elements/structure/List/List.d.ts

@@ -7,9 +7,9 @@ export type ListProps<T = unknown> = {
     items?: T[];
     source?: 'none' | 'controlled';
 };
-declare const List: ({ ref, className, subType, children, items, source }: ListProps) => import("react").JSX.Element;
+declare const List: ({ ref, className, subType, children, items, source }: ListProps) => import('react').JSX.Element;
 declare const _default: {
-    (props: import('../../../Element/hocs/withElement').WithElementProps<ListProps<unknown>>): import("react").JSX.Element;
+    (props: import('../../../Element/hocs/withElement').WithElementProps<ListProps<unknown>>): import('react').JSX.Element;
     displayName: string;
 };
 export default _default;

package/dist/elements/structure/List/ListItem/ListItem.d.ts

@@ -4,9 +4,9 @@ export type ListItemProps = {
     className: string;
     children: ReactNode;
 };
-declare const ListItem: ({ ref, className, children }: ListItemProps) => import("react").JSX.Element;
+declare const ListItem: ({ ref, className, children }: ListItemProps) => import('react').JSX.Element;
 declare const _default: {
-    (props: import('../../../../Element/hocs/withElement').WithElementProps<ListItemProps>): import("react").JSX.Element;
+    (props: import('../../../../Element/hocs/withElement').WithElementProps<ListItemProps>): import('react').JSX.Element;
     displayName: string;
 };
 export default _default;

package/dist/elements/structure/List/ListItem/Settings.d.ts

@@ -1,2 +1,2 @@
-declare const Settings: () => import("react").JSX.Element;
+declare const Settings: () => import('react').JSX.Element;
 export default Settings;

package/dist/elements/structure/List/ListItem/index.d.ts

@@ -1,5 +1,5 @@
 declare const ListItem: {
-    (props: import('../../../../Element/hocs/withElement').WithElementProps<import('./ListItem').ListItemProps>): import("react").JSX.Element;
+    (props: import('../../../../Element/hocs/withElement').WithElementProps<import('./ListItem').ListItemProps>): import('react').JSX.Element;
     displayName: string;
 } & {
     readonly type: "listItem";

package/dist/elements/structure/List/Settings.d.ts

@@ -3,5 +3,5 @@ type SettingsProps = {
     source?: 'none' | 'controlled';
     onUpdate?: (key: string, value: string | boolean | number) => void;
 };
-declare const Settings: ({ subType, source, onUpdate }: SettingsProps) => import("react").JSX.Element;
+declare const Settings: ({ subType, source, onUpdate }: SettingsProps) => import('react').JSX.Element;
 export default Settings;

package/dist/elements/structure/List/index.d.ts

@@ -1,10 +1,10 @@
 declare const List: {
-    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./List').ListProps<unknown>>): import("react").JSX.Element;
+    (props: import('../../../Element/hocs/withElement').WithElementProps<import('./List').ListProps<unknown>>): import('react').JSX.Element;
     displayName: string;
 } & {
     plugins: {
         listItem: {
-            (props: import('../../../Element/hocs/withElement').WithElementProps<import('./ListItem/ListItem').ListItemProps>): import("react").JSX.Element;
+            (props: import('../../../Element/hocs/withElement').WithElementProps<import('./ListItem/ListItem').ListItemProps>): import('react').JSX.Element;
             displayName: string;
         } & {
             readonly type: "listItem";

package/dist/elements/structure/List/modes/ListBasic.d.ts

@@ -5,5 +5,5 @@ export type ListBasicProps = {
     subType?: 'ul' | 'ol';
     children?: ReactNode;
 };
-declare const ListBasic: ({ ref, className, subType, children }: ListBasicProps) => import("react").JSX.Element;
+declare const ListBasic: ({ ref, className, subType, children }: ListBasicProps) => import('react').JSX.Element;
 export default ListBasic;