@petrarca/sonnet-schema-designer 0.4.2

package/dist/index.d.ts

@@ -0,0 +1,531 @@
+import { JsonSchemaProperty, JsonSchema, UISchema, UILayoutConfig, UISchemaOptions } from '@petrarca/sonnet-core/schema';
+import { z } from 'zod';
+import React from 'react';
+import { WidgetOptionDef } from '@petrarca/sonnet-forms/widget-options';
+import { TableUiSchema } from '@petrarca/sonnet-ui';
+
+/**
+ * Path navigation over a JsonSchema tree.
+ *
+ * A property path is an array of property keys from the root down to a
+ * property, e.g. ["address", "city"]. Object children nest through
+ * `properties`; array children nest through `items.properties`. The path names
+ * the property and the navigator descends through `items` transparently, so an
+ * array-of-objects and its item object share one editing surface.
+ */
+
+type PropertyPath = string[];
+/** Serialize a path for use as a stable React key or selection id. */
+declare function pathKey(path: PropertyPath): string;
+/** Whether two paths refer to the same property. */
+declare function samePath(a: PropertyPath | null, b: PropertyPath | null): boolean;
+/** The container that holds a property's children, or undefined for scalars. */
+declare function childContainer(prop: JsonSchemaProperty): Record<string, JsonSchemaProperty> | undefined;
+/** Resolve a path to its property definition, or undefined if not found. */
+declare function getProperty(schema: JsonSchema, path: PropertyPath): JsonSchemaProperty | undefined;
+/** Whether a property has (or can have) child properties. */
+declare function isContainer(prop: JsonSchemaProperty): boolean;
+/** The child properties of a property, or an empty map for scalars. */
+declare function childrenOf(prop: JsonSchemaProperty): Record<string, JsonSchemaProperty>;
+
+/**
+ * Read-shaping: turn a JsonSchema into a property tree for the designer UI.
+ *
+ * Pure, no React. Ordering follows the renderer's rule: an explicit x-ui-order
+ * first, then remaining keys in declaration order.
+ */
+
+type PropertyKind = "scalar" | "enum" | "object" | "array";
+interface PropertyNode {
+    path: PropertyPath;
+    key: string;
+    property: JsonSchemaProperty;
+    kind: PropertyKind;
+    required: boolean;
+    /** Short type descriptor for the tree row, e.g. "string", "object[]". */
+    typeLabel: string;
+    /** Resolved widget override (x-ui-widget) if any. */
+    widget?: string;
+    children: PropertyNode[];
+}
+/** Classify a property into a tree kind. */
+declare function propertyKind(prop: JsonSchemaProperty): PropertyKind;
+/** Order keys by explicit x-ui-order, then remaining declaration order. */
+declare function orderedKeys(properties: Record<string, JsonSchemaProperty>, order: string[] | undefined): string[];
+/** Build the full property tree for a schema. */
+declare function buildPropertyTree(schema: JsonSchema): PropertyNode[];
+/**
+ * A layout scope: a container whose fields can be arranged into rows. Root is
+ * the form itself (path []); nested scopes are object/array containers.
+ */
+interface LayoutScope {
+    /** Empty for root, otherwise the property path to the container. */
+    path: string[];
+    /** Human label, e.g. "Form (root)" or "contact" or "addresses (items)". */
+    label: string;
+}
+/** Enumerate all layout scopes: the root form plus every object/array container. */
+declare function layoutScopes(schema: JsonSchema): LayoutScope[];
+
+/**
+ * Pure edit operations over { schema, uiSchema }.
+ *
+ * Every function returns a new pair; nothing mutates in place. Operations keep
+ * the schema and uiSchema consistent -- renaming a property rewrites the property
+ * key, the uiSchema entry, the required entry, and any x-ui-order reference at
+ * the same level. Mirrors the graph-model/mutate.ts discipline.
+ */
+
+type UiSchemaMap = Record<string, UISchema>;
+interface DesignerModel {
+    schema: JsonSchema;
+    uiSchema: UiSchemaMap;
+}
+/** A default property for a newly created property of a given kind. */
+declare function newProperty(kind: "scalar" | "object" | "array"): JsonSchemaProperty;
+/** Add a property under a parent path (root when empty). Returns the new model. */
+declare function addProperty(model: DesignerModel, parentPath: PropertyPath, kind: "scalar" | "object" | "array"): {
+    model: DesignerModel;
+    path: PropertyPath;
+};
+/** Delete the property at path. Returns the new model. */
+declare function deleteProperty(model: DesignerModel, path: PropertyPath): DesignerModel;
+/** Rename the property at path. Rewrites key, order, required, and uiSchema. */
+declare function renameProperty(model: DesignerModel, path: PropertyPath, nextKey: string): {
+    model: DesignerModel;
+    path: PropertyPath;
+};
+/** Move the property at path up (-1) or down (+1) among its siblings. */
+declare function moveProperty(model: DesignerModel, path: PropertyPath, direction: -1 | 1): DesignerModel;
+/** Toggle whether the property at path is required among its siblings. */
+declare function setRequired(model: DesignerModel, path: PropertyPath, required: boolean): DesignerModel;
+/** Replace the property definition at path (merges the given partial). */
+declare function updateProperty(model: DesignerModel, path: PropertyPath, patch: Partial<JsonSchemaProperty>): DesignerModel;
+/**
+ * Change the type of the property at path, reshaping structural keys: switching to
+ * object adds an empty `properties`; to array adds `items`; leaving them strips
+ * those keys. Type-specific validation keys that no longer apply are dropped.
+ */
+declare function changePropertyType(model: DesignerModel, path: PropertyPath, nextType: JsonSchemaProperty["type"]): DesignerModel;
+/** One enum choice: a value and an optional display label. */
+interface EnumChoice {
+    value: string;
+    label?: string;
+}
+declare function setEnum(model: DesignerModel, path: PropertyPath, choices: EnumChoice[]): DesignerModel;
+/** Read the current enum choices for a property + its uiSchema entry. */
+declare function readEnumChoices(prop: JsonSchemaProperty, uiEntry: UISchema | undefined): EnumChoice[];
+/** Table presentation hints for a property (embedded in the schema). */
+interface TableHints {
+    cell?: string;
+    cellOptions?: Record<string, unknown>;
+    column?: NonNullable<JsonSchemaProperty["x-ui-column"]>;
+}
+/**
+ * Set (or clear) a property's table hints: x-ui-cell, x-ui-cell-options, and
+ * x-ui-column. These live embedded on the property (EntityTable reads them
+ * there). Empty values clear the corresponding key.
+ */
+declare function setTableHints(model: DesignerModel, path: PropertyPath, hints: TableHints): DesignerModel;
+/** Read a property's current table hints. */
+declare function readTableHints(prop: JsonSchemaProperty): TableHints;
+/** Read the UISchema entry for a property path, or undefined. */
+declare function getUiEntryAtPath(uiSchema: UiSchemaMap, path: PropertyPath): UISchema | undefined;
+/** Set (or clear) the UISchema entry at a property path (any nesting depth). */
+declare function setUiEntry(model: DesignerModel, path: PropertyPath, entry: UISchema | undefined): DesignerModel;
+/**
+ * Set (or clear) the x-ui-layout of an object/array property at path. Object
+ * layout lives on the property; array layout lives on `items`.
+ */
+declare function setPropertyLayout(model: DesignerModel, path: PropertyPath, layout: UILayoutConfig | undefined): DesignerModel;
+/** Set (or clear) the root form layout (uiSchema["x-ui-layout"]). */
+declare function setRootLayout(model: DesignerModel, layout: UILayoutConfig | undefined): DesignerModel;
+/**
+ * Set (or clear) the root layout rows (uiSchema["x-ui-layout"].rows),
+ * preserving other x-ui-layout keys. Clearing rows to empty removes the key;
+ * if x-ui-layout then has no keys, it is removed entirely.
+ */
+declare function setRootLayoutRows(model: DesignerModel, rows: UILayoutConfig["rows"]): DesignerModel;
+/**
+ * Set the layout rows for a scope: the root form (path []) or an object/array
+ * container (its property path). Root rows live in uiSchema["x-ui-layout"];
+ * a container's rows live on the property's x-ui-layout (array -> items).
+ * Preserves other x-ui-layout keys.
+ */
+declare function setScopedLayoutRows(model: DesignerModel, scopePath: PropertyPath, rows: UILayoutConfig["rows"]): DesignerModel;
+/** Read the current x-ui-layout for a scope (root or a container property). */
+declare function getScopedLayout(schema: JsonSchema, uiSchema: UiSchemaMap, scopePath: PropertyPath): UILayoutConfig | undefined;
+/**
+ * Merge scalar layout options (direction/gap/labels/compact) into a scope's
+ * x-ui-layout, preserving rows and other keys. Undefined values clear the key.
+ */
+declare function setScopedLayoutOptions(model: DesignerModel, scopePath: PropertyPath, options: Pick<UILayoutConfig, "direction" | "gap" | "labels" | "compact">): DesignerModel;
+/** Set (or clear) the root global options (uiSchema["x-ui-globalOptions"]). */
+declare function setGlobalOptions(model: DesignerModel, options: UISchemaOptions | undefined): DesignerModel;
+
+/**
+ * Type -> compatible form widgets for the inspector's widget dropdown.
+ *
+ * Mirrors the renderer's resolution vocabulary (sonnet-forms widgetResolver):
+ * the dropdown offers widgets that make sense for a property's type, plus an
+ * "Auto" choice (value null) that clears x-ui-widget and lets the renderer
+ * resolve from structure/type. Keep aligned with DEFAULT_WIDGETS.
+ */
+
+interface WidgetChoice {
+    /** x-ui-widget value (lowercase alias), or null for Auto (no override). */
+    value: string | null;
+    label: string;
+}
+/** Widgets offered for a property, Auto first. */
+declare function compatibleWidgets(prop: JsonSchemaProperty): WidgetChoice[];
+
+/**
+ * Output shaping: merge a separate uiSchema map's form hints into the JSON
+ * schema as embedded x-ui-* keys, for consumers that want a single
+ * self-contained schema.
+ *
+ * The designer edits the two artifacts separately (clean data/presentation
+ * split); embedding is applied only at the emit boundary when outputMode is
+ * "embedded". Only top-level form hints are embedded in v1 (x-ui-widget,
+ * x-ui-options, x-ui-title, x-ui-placeholder, x-ui-description), matching what
+ * uiSchema carries for top-level properties.
+ */
+
+/**
+ * Return a new schema with each top-level property's uiSchema form hints copied
+ * onto the corresponding property as x-ui-* keys. The input schema/uiSchema are
+ * not mutated. uiSchema hints win over any pre-existing embedded key.
+ */
+declare function embedUiSchema(schema: JsonSchema, uiSchema: Record<string, UISchema>): JsonSchema;
+
+/**
+ * SchemaDesigner capabilities -- a small profile that gates what a consumer can
+ * author. Mirrors the discipline of GraphModelEditor's capabilities: the Zod
+ * schema below is the single source of truth, the TypeScript types are inferred
+ * from it, and `resolveCapabilities` applies defaults (with `readOnly` as a
+ * fully-locked shorthand). Every field is optional and defaults to the most
+ * permissive value, so adding a capability never tightens an existing profile.
+ *
+ * Design: docs/design/schema-designer.md, section "Capability gating".
+ */
+
+/**
+ * A tab the center pane can offer. "form" / "table" / "json" preview the
+ * schema; "capabilities" is a meta-editor for the profile itself (a dev /
+ * power-user affordance), not a preview -- it is opt-in and never in a default.
+ */
+type PreviewKind = "form" | "table" | "json" | "capabilities";
+/**
+ * The capabilities schema. Small by design -- it covers the real consumer needs
+ * (sestina's audit-event and terminology schema editors) without a per-area
+ * matrix we do not use yet.
+ */
+declare const capabilitiesSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        data: "data";
+    }>>;
+    previews: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        form: "form";
+        table: "table";
+        json: "json";
+        capabilities: "capabilities";
+    }>>>;
+    editablePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * The capabilities a consumer may pass. Inferred from the schema, with all
+ * fields optional on input (defaults are applied by resolveCapabilities).
+ */
+type SchemaDesignerCapabilities = z.input<typeof capabilitiesSchema>;
+/** The fully-resolved capabilities, plus the derived flags used for gating. */
+interface ResolvedCapabilities {
+    mode: "data" | "full";
+    /** Effective preview list (defaulted by mode when not provided). */
+    previews: PreviewKind[];
+    /** JSON Pointer paths whose children are editable; empty = no scoping. */
+    editablePaths: string[];
+    /** No structural edits at all (readOnly shorthand). */
+    locked: boolean;
+    /** editablePaths is non-empty -- only designated subtrees are editable. */
+    scoped: boolean;
+    /** The Capabilities editor tab is listed in previews. */
+    showCapabilities: boolean;
+    /** Whether the center pane renders at all (previews non-empty). */
+    showPreview: boolean;
+}
+/**
+ * Resolve the effective capabilities: readOnly wins (fully locked), otherwise
+ * parse the provided capabilities (applying per-field defaults). Invalid input
+ * falls back to permissive defaults rather than throwing.
+ */
+declare function resolveCapabilities(capabilities: SchemaDesignerCapabilities | undefined, readOnly: boolean | undefined): ResolvedCapabilities;
+/** Result of validating an untrusted capabilities object. */
+type CapabilitiesValidation = {
+    ok: true;
+    value: SchemaDesignerCapabilities;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Validate a hand-authored / external capabilities object. Returns the parsed
+ * value or a list of readable error messages. Does not throw.
+ */
+declare function validateCapabilities(input: unknown): CapabilitiesValidation;
+
+/**
+ * useDesignerState -- owns the designer's { schema, uiSchema, selection } and
+ * exposes bound mutation operations.
+ *
+ * Controlled: pass `schema` + `uiSchema` + `onChange`; the hook holds no schema
+ * state and every op calls `onChange`. Uncontrolled: pass `initialSchema`
+ * (+ optional `initialUiSchema`); the hook manages the schema internally.
+ * Selection (the active property path) is always internal UI state.
+ */
+
+interface UseDesignerStateArgs {
+    schema?: JsonSchema;
+    uiSchema?: UiSchemaMap;
+    initialSchema?: JsonSchema;
+    initialUiSchema?: UiSchemaMap;
+    onChange?: (schema: JsonSchema, uiSchema: UiSchemaMap) => void;
+    readOnly?: boolean;
+    capabilities?: SchemaDesignerCapabilities;
+}
+interface DesignerState {
+    schema: JsonSchema;
+    uiSchema: UiSchemaMap;
+    selection: PropertyPath | null;
+    readOnly: boolean;
+    /** Resolved capability profile (readOnly + editablePaths applied). */
+    capabilities: ResolvedCapabilities;
+    /** Whether the property at path may be renamed / deleted / retyped / reordered. */
+    canEditProperty: (path: PropertyPath) => boolean;
+    /** Whether a child property may be added to the container at path (root = []). */
+    canAddChild: (path: PropertyPath) => boolean;
+    select: (path: PropertyPath | null) => void;
+    addProperty: (parentPath: PropertyPath, kind: "scalar" | "object" | "array") => void;
+    deleteProperty: (path: PropertyPath) => void;
+    renameProperty: (path: PropertyPath, nextKey: string) => void;
+    moveProperty: (path: PropertyPath, direction: -1 | 1) => void;
+    setRequired: (path: PropertyPath, required: boolean) => void;
+    updateProperty: (path: PropertyPath, patch: Partial<JsonSchemaProperty>) => void;
+    changePropertyType: (path: PropertyPath, nextType: JsonSchemaProperty["type"]) => void;
+    setEnum: (path: PropertyPath, choices: EnumChoice[]) => void;
+    setUiEntry: (path: PropertyPath, entry: UISchema | undefined) => void;
+    setTableHints: (path: PropertyPath, hints: TableHints) => void;
+    setPropertyLayout: (path: PropertyPath, layout: UILayoutConfig | undefined) => void;
+    setRootLayout: (layout: UILayoutConfig | undefined) => void;
+    setRootLayoutRows: (rows: UILayoutConfig["rows"]) => void;
+    setScopedLayoutRows: (scopePath: PropertyPath, rows: UILayoutConfig["rows"]) => void;
+    setScopedLayoutOptions: (scopePath: PropertyPath, options: Pick<UILayoutConfig, "direction" | "gap" | "labels" | "compact">) => void;
+    setGlobalOptions: (options: UISchemaOptions | undefined) => void;
+}
+declare function useDesignerState(args: UseDesignerStateArgs): DesignerState;
+
+/**
+ * SchemaDesigner -- visual, controlled designer for a JsonSchema (+ uiSchema).
+ *
+ * Layout: Tree | Preview | Inspector. The preview (the live form) is the hero
+ * and takes the flexible center, matching visual-builder convention; the
+ * inspector is the resizable/collapsible right pane. Controlled via `schema` +
+ * `uiSchema` + `onChange`, or uncontrolled via `initialSchema`. Read-only is a
+ * mode of the same component.
+ *
+ * This is the assembly shell; the tree, preview, and inspector are built up
+ * incrementally.
+ */
+
+interface SchemaDesignerProps {
+    /** Controlled schema. Provide with onChange. */
+    schema?: JsonSchema;
+    /** Controlled uiSchema map (form presentation hints). */
+    uiSchema?: Record<string, UISchema>;
+    /** Uncontrolled seed schema (used when `schema` is omitted). */
+    initialSchema?: JsonSchema;
+    /** Uncontrolled seed uiSchema. */
+    initialUiSchema?: Record<string, UISchema>;
+    /**
+     * Called on every edit with the new schema + uiSchema (always the separate
+     * form: schema is the data model, form hints live in uiSchema). Use the
+     * exported `embedUiSchema` helper if a single self-contained schema is wanted.
+     */
+    onChange?: (schema: JsonSchema, uiSchema: Record<string, UISchema>) => void;
+    /** View-only: no edit affordances, onChange never fires. Shorthand for a fully-locked profile. */
+    readOnly?: boolean;
+    /** Capability profile: gates data/full mode, preview renderers, and scoped editing. */
+    capabilities?: SchemaDesignerCapabilities;
+    /** Option descriptors for custom widgets, keyed by widget name (merged over built-ins). */
+    widgetOptions?: Record<string, WidgetOptionDef[]>;
+}
+declare function SchemaDesigner(props: SchemaDesignerProps): React.ReactElement;
+
+/**
+ * PropertyTree -- the left pane. Renders the schema's properties as a
+ * hierarchical list with select / add / delete / reorder. Row idiom matches
+ * graph-model/TypeDetailPanel for cross-editor consistency.
+ */
+
+interface PropertyTreeProps {
+    state: DesignerState;
+    /** When provided, renders a collapse button in the header. */
+    onCollapse?: () => void;
+}
+declare function PropertyTree({ state, onCollapse, }: PropertyTreeProps): React.ReactElement;
+
+/**
+ * PreviewPane -- the center pane. Tabs: Form (live rendered form), JSON Schema
+ * (the data model), and UI Schema (the presentation map). The form is the
+ * universal sanity check; the two JSON views are read-only.
+ *
+ * Additional renderers (table, tree, detail) plug in as more tabs without
+ * touching this contract -- each takes the same schema + uiSchema + data.
+ */
+
+interface PreviewPaneProps {
+    state: DesignerState;
+    /** The current (editable) capabilities profile. */
+    capabilities?: SchemaDesignerCapabilities;
+    /** Apply an edited profile (from the Capabilities tab). */
+    onCapabilitiesChange?: (next: SchemaDesignerCapabilities) => void;
+}
+declare function PreviewPane({ state, capabilities, onCapabilitiesChange, }: PreviewPaneProps): React.ReactElement;
+
+/**
+ * TablePreview -- renders the schema as an EntityTable using auto-generated
+ * sample rows. Columns and cells come from the resolver's defaults plus any
+ * x-ui-column / x-ui-cell hints embedded in the schema.
+ */
+
+interface TablePreviewProps {
+    schema: JsonSchema;
+    uiSchema?: TableUiSchema;
+}
+declare function TablePreview({ schema, uiSchema, }: TablePreviewProps): React.ReactElement;
+
+/**
+ * Generate plausible sample rows from a JsonSchema, for the table preview.
+ *
+ * Pure. Produces a few rows with a value per top-level property, chosen by
+ * type / format / enum so the table shows realistic content. Nested objects and
+ * arrays get simple placeholders (tables typically show scalar columns; the
+ * cell renderer decides how to display the rest).
+ */
+
+type Row = Record<string, unknown>;
+/** Build `count` sample rows for a schema's top-level properties. */
+declare function sampleRows(schema: JsonSchema, count?: number): Row[];
+
+/**
+ * FormLayoutDesigner -- visual editor for the form's row layout
+ * (x-ui-layout.rows). Two columns: an "Available" pool of unassigned top-level
+ * properties (left) and the row designer (right). Properties are dragged
+ * (native HTML5 DnD) between the pool and rows; rows can be added, removed,
+ * reordered, and given a CSS grid-template-columns value.
+ *
+ * This is a bespoke visual designer (not a meta-schema form) -- the first of a
+ * planned family of "*Designer" surfaces for spatial authoring tasks.
+ */
+
+interface FormLayoutDesignerProps {
+    state: DesignerState;
+}
+declare function FormLayoutDesigner({ state, }: FormLayoutDesignerProps): React.ReactElement;
+
+/**
+ * Inspector -- the right pane. Resolves the selected property and hosts the tabbed
+ * editors (Data now; UI and Layout added incrementally). Empty state when no
+ * property is selected.
+ */
+
+interface InspectorProps {
+    state: DesignerState;
+    /** Option descriptors for custom widgets (merged over built-ins). */
+    widgetOptions?: Record<string, WidgetOptionDef[]>;
+}
+declare function Inspector({ state, widgetOptions, }: InspectorProps): React.ReactElement;
+
+/**
+ * DataTab -- edits a property's data definition (type, title, description,
+ * default, required, validation) via a meta-schema rendered with
+ * JsonSchemaFormRenderer. Type and required are routed to dedicated mutations
+ * (they reshape structure / live on the parent); the rest is a property patch.
+ */
+
+interface DataTabProps {
+    node: PropertyNode;
+    state: DesignerState;
+}
+declare function DataTab({ node, state }: DataTabProps): React.ReactElement;
+
+/**
+ * UITab -- edits a property's form presentation hints: the widget (x-ui-widget)
+ * and its options (x-ui-options).
+ *
+ * The widget dropdown offers widgets compatible with the property's type (Auto
+ * clears the override). The options editor is a JsonSchemaFormRenderer over a
+ * schema derived from the selected widget's WidgetOptionDef[] (from the
+ * design-time @petrarca/sonnet-forms/widget-options layer). Widgets with no
+ * descriptor fall back to a raw JSON editor for x-ui-options.
+ */
+
+interface UITabProps {
+    node: PropertyNode;
+    state: DesignerState;
+    /** Consumer-supplied option descriptors for custom widgets (merged over built-ins). */
+    widgetOptions?: Record<string, WidgetOptionDef[]>;
+}
+declare function UITab({ node, state, widgetOptions, }: UITabProps): React.ReactElement;
+
+/**
+ * EnumEditor -- edits a scalar property's allowed values (enum) and optional
+ * display labels, as a row list.
+ *
+ * Each choice is a row: [value] [label] [remove]. An Add button appends a row.
+ * Values write to property.enum; labels write to x-ui-options.enumNames (only
+ * for top-level properties). All changes route through setEnum, which normalizes,
+ * dedupes, and clears when empty.
+ */
+
+interface EnumEditorProps {
+    node: PropertyNode;
+    state: DesignerState;
+}
+declare function EnumEditor({ node, state, }: EnumEditorProps): React.ReactElement;
+
+/**
+ * TableHintsTab -- edits a property's table presentation hints (x-ui-cell,
+ * x-ui-column, x-ui-cell-options), which EntityTable reads. These are embedded
+ * on the schema property (not the uiSchema map). Live in the Table preview.
+ *
+ * The cell renderer list is derived from sonnet-ui's exported CELL_RENDERERS,
+ * so it stays in sync with the actual table renderers. Cell options are edited
+ * as raw JSON (varies per renderer).
+ */
+
+interface TableHintsTabProps {
+    node: PropertyNode;
+    state: DesignerState;
+}
+declare function TableHintsTab({ node, state, }: TableHintsTabProps): React.ReactElement;
+
+/**
+ * FormSettingsSheet -- form-level (root) settings in a right-side Sheet, opened
+ * from a gear button. Holds settings that are not tied to a single property:
+ * the root form layout (x-ui-layout) and global options (x-ui-globalOptions).
+ *
+ * Uses the house-standard Sheet pattern (as in graph-model's PropertyFormSheet).
+ * Kept out of the inspector's per-property tabs, which do not scale to
+ * form-wide concerns.
+ */
+
+interface FormSettingsSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    state: DesignerState;
+}
+declare function FormSettingsSheet({ open, onOpenChange, state, }: FormSettingsSheetProps): React.ReactElement;
+
+export { type CapabilitiesValidation, DataTab, type DesignerModel, type DesignerState, type EnumChoice, EnumEditor, FormLayoutDesigner, FormSettingsSheet, Inspector, type LayoutScope, PreviewPane, type PropertyKind, type PropertyNode, type PropertyPath, PropertyTree, type ResolvedCapabilities, SchemaDesigner, type SchemaDesignerCapabilities, type SchemaDesignerProps, type TableHints, TableHintsTab, TablePreview, UITab, type UiSchemaMap, type UseDesignerStateArgs, type WidgetChoice, addProperty, buildPropertyTree, capabilitiesSchema, changePropertyType, childContainer, childrenOf, compatibleWidgets, deleteProperty, embedUiSchema, getProperty, getScopedLayout, getUiEntryAtPath, isContainer, layoutScopes, moveProperty, newProperty, orderedKeys, pathKey, propertyKind, readEnumChoices, readTableHints, renameProperty, resolveCapabilities, samePath, sampleRows, setEnum, setGlobalOptions, setPropertyLayout, setRequired, setRootLayout, setRootLayoutRows, setScopedLayoutOptions, setScopedLayoutRows, setTableHints, setUiEntry, updateProperty, useDesignerState, validateCapabilities };