@getaster/elements 0.0.0-stage → 0.1.0-preview.0

package/dist/composition/builtins.d.ts

@@ -0,0 +1,1130 @@
+import { Collection, Command, DataContext, EditModel, FilterDraft, ListEdit, Selection, SharedFilters, Tree } from "@getaster/data";
+import { type CompositeType } from "./contracts.ts";
+import { PickerOptions } from "../picker/options.ts";
+import { TreeChoices } from "../picker/tree-choices.ts";
+/** Reusable public control contracts. Select entries explicitly for an application's allowlist. */
+export declare const asterComponents: Readonly<{
+    Button: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly busyLabel: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly confirmLabel: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly busy: CompositeType<boolean | import("@preact/signals-core").ReadonlySignal<boolean>> & {
+                readonly optional: true;
+            };
+            readonly variant: CompositeType<"secondary" | "primary"> & {
+                readonly optional: true;
+            };
+            readonly type: CompositeType<"submit" | "button"> & {
+                readonly optional: true;
+            };
+            readonly icon: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly reason: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Field: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly value: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly placeholder: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly readOnly: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly keyboard: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly trailing: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly field: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly labelled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly sharedReasons: CompositeType<Map<string, string>> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    NumberField: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly value: CompositeType<import("../index.ts").NumericValue> & {
+                readonly optional: true;
+            };
+            readonly numericType: CompositeType<"integer" | "decimal" | "float"> & {
+                readonly optional: true;
+            };
+            readonly min: Omit<CompositeType<string | number>, "validate"> & CompositeType<string | number | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly max: Omit<CompositeType<string | number>, "validate"> & CompositeType<string | number | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly step: Omit<CompositeType<string | number>, "validate"> & CompositeType<string | number | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly stepButtons: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly prefixText: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly suffixText: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly placeholder: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly readOnly: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly format: CompositeType<((value: import("../index.ts").NumericValue) => string) | undefined> & {
+                readonly optional: true;
+            };
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly field: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly labelled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly sharedReasons: CompositeType<Map<string, string>> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    CompositeField: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly fields: CompositeType<readonly string[]> & {
+                readonly item: CompositeType<string>;
+            } & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly help: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly error: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly disabled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly readOnly: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly content: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly value: CompositeType<unknown> & {
+                readonly optional: true;
+            };
+            readonly renderValue: CompositeType<((context: import("../index.ts").CompositeFieldContext<unknown>) => import("../index.ts").View) | undefined> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Stack: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: import("./element.ts").ElementContract<{
+            readonly direction: {
+                readonly type: CompositeType<"horizontal" | "vertical">;
+                readonly initial: () => "horizontal" | "vertical";
+                readonly description: string;
+            };
+            readonly gap: {
+                readonly type: CompositeType<"small" | "none" | "medium" | "large">;
+                readonly initial: () => "small" | "none" | "medium" | "large";
+                readonly description: string;
+            };
+            readonly align: {
+                readonly type: CompositeType<"center" | "stretch" | "start" | "end" | "baseline">;
+                readonly initial: () => "center" | "stretch" | "start" | "end" | "baseline";
+                readonly description: string;
+            };
+            readonly justify: {
+                readonly type: CompositeType<"center" | "start" | "end" | "space-between" | "space-around">;
+                readonly initial: () => "center" | "start" | "end" | "space-between" | "space-around";
+                readonly description: string;
+            };
+            readonly wrap: {
+                readonly type: CompositeType<boolean>;
+                readonly initial: () => boolean;
+                readonly description: string;
+            };
+            readonly responsive: {
+                readonly type: CompositeType<boolean>;
+                readonly initial: () => boolean;
+                readonly description: string;
+            };
+            readonly content: {
+                readonly type: CompositeType<import("../index.ts").View>;
+                readonly initial: () => import("../index.ts").View;
+                readonly description: string;
+            };
+        }>;
+    }>;
+    HorizontalLayout: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: import("./element.ts").ElementContract<{
+            readonly direction: {
+                readonly type: CompositeType<"horizontal" | "vertical">;
+                readonly initial: () => "horizontal" | "vertical";
+                readonly description: string;
+            };
+            readonly gap: {
+                readonly type: CompositeType<"small" | "none" | "medium" | "large">;
+                readonly initial: () => "small" | "none" | "medium" | "large";
+                readonly description: string;
+            };
+            readonly align: {
+                readonly type: CompositeType<"center" | "stretch" | "start" | "end" | "baseline">;
+                readonly initial: () => "center" | "stretch" | "start" | "end" | "baseline";
+                readonly description: string;
+            };
+            readonly justify: {
+                readonly type: CompositeType<"center" | "start" | "end" | "space-between" | "space-around">;
+                readonly initial: () => "center" | "start" | "end" | "space-between" | "space-around";
+                readonly description: string;
+            };
+            readonly wrap: {
+                readonly type: CompositeType<boolean>;
+                readonly initial: () => boolean;
+                readonly description: string;
+            };
+            readonly responsive: {
+                readonly type: CompositeType<boolean>;
+                readonly initial: () => boolean;
+                readonly description: string;
+            };
+            readonly content: {
+                readonly type: CompositeType<import("../index.ts").View>;
+                readonly initial: () => import("../index.ts").View;
+                readonly description: string;
+            };
+        }>;
+    }>;
+    VerticalLayout: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: import("./element.ts").ElementContract<{
+            readonly direction: {
+                readonly type: CompositeType<"horizontal" | "vertical">;
+                readonly initial: () => "horizontal" | "vertical";
+                readonly description: string;
+            };
+            readonly gap: {
+                readonly type: CompositeType<"small" | "none" | "medium" | "large">;
+                readonly initial: () => "small" | "none" | "medium" | "large";
+                readonly description: string;
+            };
+            readonly align: {
+                readonly type: CompositeType<"center" | "stretch" | "start" | "end" | "baseline">;
+                readonly initial: () => "center" | "stretch" | "start" | "end" | "baseline";
+                readonly description: string;
+            };
+            readonly justify: {
+                readonly type: CompositeType<"center" | "start" | "end" | "space-between" | "space-around">;
+                readonly initial: () => "center" | "start" | "end" | "space-between" | "space-around";
+                readonly description: string;
+            };
+            readonly wrap: {
+                readonly type: CompositeType<boolean>;
+                readonly initial: () => boolean;
+                readonly description: string;
+            };
+            readonly responsive: {
+                readonly type: CompositeType<boolean>;
+                readonly initial: () => boolean;
+                readonly description: string;
+            };
+            readonly content: {
+                readonly type: CompositeType<import("../index.ts").View>;
+                readonly initial: () => import("../index.ts").View;
+                readonly description: string;
+            };
+        }>;
+    }>;
+    Breadcrumbs: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: import("./element.ts").ElementContract<{
+            readonly items: {
+                readonly type: CompositeType<readonly import("../index.ts").BreadcrumbItem[]>;
+                readonly initial: () => readonly import("../index.ts").BreadcrumbItem[];
+                readonly description: string;
+            };
+            readonly label: {
+                readonly type: CompositeType<string>;
+                readonly initial: () => string;
+                readonly description: string;
+            };
+            readonly maxVisible: {
+                readonly type: CompositeType<number>;
+                readonly initial: () => number;
+                readonly description: string;
+            };
+        }>;
+    }>;
+    Accordion: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly items: CompositeType<readonly import("../index.ts").AccordionItem[]> & {
+                readonly optional: true;
+            };
+            readonly expanded: CompositeType<readonly string[]> & {
+                readonly item: CompositeType<string>;
+            } & {
+                readonly optional: true;
+            };
+            readonly multiple: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly headingLevel: CompositeType<2 | 3 | 4> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Check: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly field: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly labelled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly sharedReasons: CompositeType<Map<string, string>> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Select: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly choices: Omit<CompositeType<readonly import("./contracts.ts").CompositeContractValues<{
+                readonly value: CompositeType<import("@getaster/data").Value>;
+                readonly label: CompositeType<string>;
+            }>[]> & {
+                readonly item: CompositeType<import("./contracts.ts").CompositeContractValues<{
+                    readonly value: CompositeType<import("@getaster/data").Value>;
+                    readonly label: CompositeType<string>;
+                }>> & {
+                    readonly fields: {
+                        readonly value: CompositeType<import("@getaster/data").Value>;
+                        readonly label: CompositeType<string>;
+                    };
+                };
+            }, "validate"> & CompositeType<readonly import("./contracts.ts").CompositeContractValues<{
+                readonly value: CompositeType<import("@getaster/data").Value>;
+                readonly label: CompositeType<string>;
+            }>[] | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly field: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly labelled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly sharedReasons: CompositeType<Map<string, string>> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Picker: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly options: CompositeType<Collection | PickerOptions | undefined> & {
+                readonly optional: true;
+            };
+            readonly display: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly valueField: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly multiple: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly values: CompositeType<readonly import("@getaster/data").Value[]> & {
+                readonly optional: true;
+            };
+            readonly placeholder: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly field: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly labelled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly sharedReasons: CompositeType<Map<string, string>> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    TreePicker: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly options: Omit<CompositeType<TreeChoices>, "validate"> & CompositeType<TreeChoices | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly placeholder: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly field: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly labelled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly sharedReasons: CompositeType<Map<string, string>> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    DateField: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly field: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly labelled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly sharedReasons: CompositeType<Map<string, string>> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Choice: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly options: CompositeType<readonly import("./contracts.ts").CompositeContractValues<{
+                readonly value: CompositeType<import("@getaster/data").Value>;
+                readonly label: CompositeType<string>;
+            }>[]> & {
+                readonly item: CompositeType<import("./contracts.ts").CompositeContractValues<{
+                    readonly value: CompositeType<import("@getaster/data").Value>;
+                    readonly label: CompositeType<string>;
+                }>> & {
+                    readonly fields: {
+                        readonly value: CompositeType<import("@getaster/data").Value>;
+                        readonly label: CompositeType<string>;
+                    };
+                };
+            } & {
+                readonly optional: true;
+            };
+            readonly value: CompositeType<import("@getaster/data").Value | undefined> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly placeholder: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Switch: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly binding: CompositeType<import("../index.ts").SwitchBinding | undefined> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Grid: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly progressPolicy: CompositeType<import("./contracts.ts").CompositeContractValues<{
+                readonly delayMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                    readonly optional: true;
+                };
+                readonly minVisibleMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                    readonly optional: true;
+                };
+            }>> & {
+                readonly fields: {
+                    readonly delayMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                        readonly optional: true;
+                    };
+                    readonly minVisibleMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                        readonly optional: true;
+                    };
+                };
+            } & {
+                readonly optional: true;
+            };
+            readonly ctx: Omit<CompositeType<DataContext>, "validate"> & CompositeType<DataContext | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly set: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly base: CompositeType<import("@getaster/data").Criteria | undefined> & {
+                readonly optional: true;
+            };
+            readonly view: Omit<CompositeType<import("../index.ts").GridView>, "validate"> & CompositeType<import("../index.ts").GridView | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly publish: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly persist: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly renderers: CompositeType<Readonly<Record<string, import("../index.ts").CellRenderer>>> & {
+                readonly optional: true;
+            };
+            readonly formatters: CompositeType<Readonly<Record<string, import("../index.ts").CellFormatter>>> & {
+                readonly optional: true;
+            };
+            readonly summaries: CompositeType<readonly import("../index.ts").GridSummary[]> & {
+                readonly optional: true;
+            };
+            readonly lookups: CompositeType<Readonly<Record<string, import("../index.ts").Lookup>>> & {
+                readonly optional: true;
+            };
+            readonly rowMenu: CompositeType<(entity: import("@getaster/data").Entity, key: import("@getaster/data").KeyText) => readonly import("../index.ts").MenuItem[]> & {
+                readonly optional: true;
+            };
+            readonly tree: CompositeType<import("../index.ts").GridTree | undefined> & {
+                readonly optional: true;
+            };
+            readonly rowControls: CompositeType<((row: import("../index.ts").RowState) => readonly import("../index.ts").RowControl[]) | undefined> & {
+                readonly optional: true;
+            };
+            readonly expansion: CompositeType<import("../index.ts").Expansion | undefined> & {
+                readonly optional: true;
+            };
+            readonly editable: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly rules: CompositeType<Readonly<Record<string, import("@getaster/data").FieldRules>>> & {
+                readonly optional: true;
+            };
+            readonly empty: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly collection: Omit<CompositeType<Collection>, "validate"> & CompositeType<Collection | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly selection: Omit<CompositeType<Selection>, "validate"> & CompositeType<Selection | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly selectable: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    TileGrid: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly collection: Omit<CompositeType<Collection>, "validate"> & CompositeType<Collection | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly selection: Omit<CompositeType<Selection>, "validate"> & CompositeType<Selection | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly selectable: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly publish: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly presentTile: CompositeType<import("../index.ts").TilePresenter | undefined> & {
+                readonly optional: true;
+            };
+            readonly renderTile: CompositeType<import("../index.ts").TileRenderer | undefined> & {
+                readonly optional: true;
+            };
+            readonly actions: CompositeType<((entity: import("@getaster/data").Entity, state: import("../index.ts").TileState) => readonly import("../index.ts").MenuItem[]) | undefined> & {
+                readonly optional: true;
+            };
+            readonly empty: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly layout: CompositeType<"content" | "uniform"> & {
+                readonly optional: true;
+            };
+            readonly virtualized: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Listbox: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly collection: Omit<CompositeType<Collection>, "validate"> & CompositeType<Collection | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly selection: Omit<CompositeType<Selection>, "validate"> & CompositeType<Selection | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly publish: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly renderRow: CompositeType<import("../index.ts").RowRenderer> & {
+                readonly optional: true;
+            };
+            readonly empty: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Form: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly model: Omit<CompositeType<EditModel>, "validate"> & CompositeType<EditModel | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly sections: CompositeType<readonly import("./contracts.ts").CompositeContractValues<{
+                readonly title: CompositeType<string>;
+                readonly columns: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                    readonly optional: true;
+                };
+                readonly open: Omit<CompositeType<boolean>, "validate"> & CompositeType<boolean | undefined> & {
+                    readonly optional: true;
+                };
+                readonly items: CompositeType<readonly import("../index.ts").FormItem[]> & {
+                    readonly item: CompositeType<import("../index.ts").FormItem>;
+                };
+            }>[]> & {
+                readonly item: CompositeType<import("./contracts.ts").CompositeContractValues<{
+                    readonly title: CompositeType<string>;
+                    readonly columns: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                        readonly optional: true;
+                    };
+                    readonly open: Omit<CompositeType<boolean>, "validate"> & CompositeType<boolean | undefined> & {
+                        readonly optional: true;
+                    };
+                    readonly items: CompositeType<readonly import("../index.ts").FormItem[]> & {
+                        readonly item: CompositeType<import("../index.ts").FormItem>;
+                    };
+                }>> & {
+                    readonly fields: {
+                        readonly title: CompositeType<string>;
+                        readonly columns: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                            readonly optional: true;
+                        };
+                        readonly open: Omit<CompositeType<boolean>, "validate"> & CompositeType<boolean | undefined> & {
+                            readonly optional: true;
+                        };
+                        readonly items: CompositeType<readonly import("../index.ts").FormItem[]> & {
+                            readonly item: CompositeType<import("../index.ts").FormItem>;
+                        };
+                    };
+                };
+            } & {
+                readonly optional: true;
+            };
+            readonly headingLevel: CompositeType<2 | 3 | 4> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    ListEditor: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly list: Omit<CompositeType<ListEdit>, "validate"> & CompositeType<ListEdit | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly columns: CompositeType<readonly import("../index.ts").ListColumn[]> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly addLabel: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly readOnlyReason: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly empty: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    RuleEditor: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly list: Omit<CompositeType<ListEdit>, "validate"> & CompositeType<ListEdit | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly category: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly messages: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly fields: CompositeType<PickerOptions | TreeChoices | undefined> & {
+                readonly optional: true;
+            };
+            readonly describe: CompositeType<((fieldRef: import("@getaster/data").Value | undefined) => import("@preact/signals-core").ReadonlySignal<import("../index.ts").RuleField | undefined>) | undefined> & {
+                readonly optional: true;
+            };
+            readonly readOnlyReason: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly empty: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    FilterBuilder: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly model: Omit<CompositeType<FilterDraft>, "validate"> & CompositeType<FilterDraft | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly readOnlyReason: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    TreeNavigator: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly tree: Omit<CompositeType<Tree>, "validate"> & CompositeType<Tree | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly display: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly choosable: CompositeType<((entity: import("@getaster/data").Entity) => string | undefined) | undefined> & {
+                readonly optional: true;
+            };
+            readonly headingLevel: CompositeType<2 | 1 | 3 | 4 | 5 | 6> & {
+                readonly optional: true;
+            };
+            readonly chooseLabel: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Tabs: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly renderPanel: CompositeType<((item: import("../index.ts").TabItem) => import("../index.ts").View) | undefined> & {
+                readonly optional: true;
+            };
+            readonly activation: CompositeType<"manual" | "automatic"> & {
+                readonly optional: true;
+            };
+            readonly items: CompositeType<readonly import("./contracts.ts").CompositeContractValues<{
+                readonly value: CompositeType<string>;
+                readonly label: CompositeType<string>;
+                readonly closable: Omit<CompositeType<boolean>, "validate"> & CompositeType<boolean | undefined> & {
+                    readonly optional: true;
+                };
+                readonly disabled: Omit<CompositeType<boolean>, "validate"> & CompositeType<boolean | undefined> & {
+                    readonly optional: true;
+                };
+            }>[] | import("@preact/signals-core").ReadonlySignal<readonly import("./contracts.ts").CompositeContractValues<{
+                readonly value: CompositeType<string>;
+                readonly label: CompositeType<string>;
+                readonly closable: Omit<CompositeType<boolean>, "validate"> & CompositeType<boolean | undefined> & {
+                    readonly optional: true;
+                };
+                readonly disabled: Omit<CompositeType<boolean>, "validate"> & CompositeType<boolean | undefined> & {
+                    readonly optional: true;
+                };
+            }>[]>> & {
+                readonly optional: true;
+            };
+            readonly value: CompositeType<string | import("@preact/signals-core").ReadonlySignal<string | undefined> | undefined> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly controls: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Section: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly actions: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly disabled: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly heading: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly open: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly body: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly level: CompositeType<2 | 3 | 4> & {
+                readonly optional: true;
+            };
+            readonly summary: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Split: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly orientation: CompositeType<"horizontal" | "vertical"> & {
+                readonly optional: true;
+            };
+            readonly size: CompositeType<number> & {
+                readonly optional: true;
+            };
+            readonly collapsible: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly collapsed: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly responsive: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly start: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly end: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly width: CompositeType<number> & {
+                readonly optional: true;
+            };
+            readonly min: CompositeType<number> & {
+                readonly optional: true;
+            };
+            readonly max: CompositeType<number> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly persist: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Carousel: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly slides: CompositeType<readonly import("../index.ts").Slide[]> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Slicer: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly filters: Omit<CompositeType<SharedFilters>, "validate"> & CompositeType<SharedFilters | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly empty: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    ComponentHost: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly progressPolicy: CompositeType<import("./contracts.ts").CompositeContractValues<{
+                readonly delayMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                    readonly optional: true;
+                };
+                readonly minVisibleMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                    readonly optional: true;
+                };
+            }>> & {
+                readonly fields: {
+                    readonly delayMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                        readonly optional: true;
+                    };
+                    readonly minVisibleMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                        readonly optional: true;
+                    };
+                };
+            } & {
+                readonly optional: true;
+            };
+            readonly adapter: CompositeType<import("../index.ts").ComponentAdapter | undefined> & {
+                readonly optional: true;
+            };
+            readonly alternative: CompositeType<(() => import("../index.ts").View) | undefined> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly locale: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Window: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly heading: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly content: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly managed: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly preserveContent: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly beforeClose: CompositeType<(() => boolean | Promise<boolean>) | undefined> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Dialog: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly content: CompositeType<import("../index.ts").View> & {
+                readonly optional: true;
+            };
+            readonly labelledBy: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Dashboard: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    CommandBar: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly showErrors: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly formatError: CompositeType<((error: unknown, action: Command) => string) | undefined> & {
+                readonly optional: true;
+            };
+            readonly label: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly commands: CompositeType<readonly Command<unknown>[]> & {
+                readonly item: CompositeType<Command<unknown>>;
+            } & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    ProgressStatus: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: Readonly<{
+            readonly busy: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+            readonly error: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                readonly optional: true;
+            } & {
+                readonly optional: true;
+            };
+            readonly progressPolicy: CompositeType<import("./contracts.ts").CompositeContractValues<{
+                readonly delayMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                    readonly optional: true;
+                };
+                readonly minVisibleMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                    readonly optional: true;
+                };
+            }>> & {
+                readonly fields: {
+                    readonly delayMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                        readonly optional: true;
+                    };
+                    readonly minVisibleMs: Omit<CompositeType<number>, "validate"> & CompositeType<number | undefined> & {
+                        readonly optional: true;
+                    };
+                };
+            } & {
+                readonly optional: true;
+            };
+            readonly pendingText: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly completeText: CompositeType<string> & {
+                readonly optional: true;
+            };
+            readonly reserveSpace: CompositeType<boolean> & {
+                readonly optional: true;
+            };
+        }>;
+    }>;
+    Sidebar: Readonly<Omit<import("./registry.ts").CompositeComponentType, "props"> & {
+        readonly props: import("./element.ts").ElementContract<{
+            readonly label: {
+                readonly type: CompositeType<string>;
+                readonly initial: () => string;
+                readonly description: string;
+            };
+            readonly items: {
+                readonly type: CompositeType<readonly import("../index.ts").SidebarItem[]>;
+                readonly initial: () => readonly import("../index.ts").SidebarItem[];
+                readonly description: string;
+            };
+            readonly value: {
+                readonly type: Omit<CompositeType<string>, "validate"> & CompositeType<string | undefined> & {
+                    readonly optional: true;
+                };
+                readonly initial: () => string | undefined;
+                readonly description: string;
+            };
+            readonly renderIcon: {
+                readonly type: Omit<CompositeType<(item: import("../index.ts").SidebarItem) => import("../index.ts").View>, "validate"> & CompositeType<((item: import("../index.ts").SidebarItem) => import("../index.ts").View) | undefined> & {
+                    readonly optional: true;
+                };
+                readonly initial: () => ((item: import("../index.ts").SidebarItem) => import("../index.ts").View) | undefined;
+                readonly description: string;
+            };
+            readonly compact: {
+                readonly type: CompositeType<boolean>;
+                readonly initial: () => boolean;
+                readonly description: string;
+            };
+        }>;
+    }>;
+}>;