@pstdio/ui 0.15.0 → 0.17.0

package/dist/components/overlays/attachment-chip.d.ts

@@ -0,0 +1,13 @@
+export interface AttachmentChipProps {
+    file: File;
+    /** Accessible label for the remove control; the caller owns translation. */
+    removeLabel: string;
+    disabled?: boolean;
+    onRemove: () => void;
+}
+/**
+ * A file queued for upload, before the resource it belongs to exists. Removal
+ * lives on the chip because there is no other surface between picking a file
+ * and submitting where a mistaken attachment can be taken back.
+ */
+export declare const AttachmentChip: (props: AttachmentChipProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/overlays/index.d.ts

@@ -0,0 +1,16 @@
+export type { AttachedMenuProps } from './attached-menu';
+export { AttachedMenu } from './attached-menu';
+export { AttachedPanel } from './attached-panel';
+export type { AttachmentChipProps } from './attachment-chip';
+export { AttachmentChip } from './attachment-chip';
+export { BubbleButton } from './bubble-button';
+export { BubblePanel } from './bubble-panel';
+export { DeleteConfirmationModal } from './delete-confirmation-modal';
+export type { RepoPickerDialogEntry, RepoPickerDialogProps } from './repo-picker-dialog';
+export { RepoPickerDialog } from './repo-picker-dialog';
+export type { ResourceActionMenuProps, ResourceContextAction } from './resource-context-menu';
+export { ResourceActionMenu, ResourceContextMenu } from './resource-context-menu';
+export type { SearchModalContentProps } from './search-modal-content';
+export { SearchModalContent } from './search-modal-content';
+export type { SearchableMenuItem, SearchableMenuParentList } from './searchable-menu';
+export { SearchableMenu } from './searchable-menu';

package/dist/components/{resource-context-menu.d.ts → overlays/resource-context-menu.d.ts}

@@ -1,9 +1,10 @@
 import { Menu } from '@chakra-ui/react';
-import { ComponentProps, ReactNode } from 'react';
+import { ComponentProps, ReactElement, ReactNode } from 'react';
 type MenuRootProps = ComponentProps<typeof Menu.Root>;
 export interface ResourceContextAction {
     key: string;
     label: string;
+    commandId?: string;
     onClick: () => Promise<void> | void;
     isDisabled?: boolean;
     icon?: ReactNode;
@@ -18,6 +19,17 @@ interface ResourceContextMenuProps {
     positioning?: MenuRootProps["positioning"];
     /** Keep the menu open after selecting an item — useful for menus that toggle several entries in one pass. */
     closeOnSelect?: MenuRootProps["closeOnSelect"];
+    /** Preserve the trigger tree while actions load or change. */
+    keepMountedWhenEmpty?: boolean;
 }
+export interface ResourceActionMenuProps {
+    actions: ResourceContextAction[];
+    children: ReactElement;
+    contentMinWidth?: string;
+    contentBackground?: string;
+    positioning?: MenuRootProps["positioning"];
+    closeOnSelect?: MenuRootProps["closeOnSelect"];
+}
+export declare const ResourceActionMenu: (props: ResourceActionMenuProps) => import("react/jsx-runtime").JSX.Element;
 export declare const ResourceContextMenu: (props: ResourceContextMenuProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/{search-modal-content.d.ts → overlays/search-modal-content.d.ts}

@@ -1,5 +1,5 @@
 import { KeyboardEventHandler, ReactNode, Ref } from 'react';
-import { ScrollAreaProps } from './scroll-area';
+import { ScrollAreaProps } from '../primitives/scroll-area';
 export interface SearchModalContentProps {
     children: ReactNode;
     searchValue: string;

package/dist/components/{searchable-menu.d.ts → overlays/searchable-menu.d.ts}

@@ -9,7 +9,7 @@ export interface SearchableMenuItem {
     secondaryLabel?: string;
     tooltipLabel?: ReactNode;
     icon?: ElementType;
-    variant?: "default" | "compact";
+    variant?: "default" | "compact" | "full-width";
     isDisabled?: boolean;
     isSelected?: boolean;
     onSelect?: () => void;

package/dist/components/param-editor/index.d.ts

@@ -1,2 +1,26 @@
+export { ActionInput } from './inputs/action-input';
+export { ANCHOR_GRID_VALUES, isAnchorGridValue } from './inputs/anchor-grid';
+export { AnchorGridInput } from './inputs/anchor-grid-input';
+export { ColorInput } from './inputs/color-input';
+export { DateInput } from './inputs/date-input';
+export { FileDropInput } from './inputs/file-drop-input';
+export { HorizontalTextInput } from './inputs/horizontal-text-input';
+export { NumberInput } from './inputs/number-input';
+export { RangeInput } from './inputs/range-input';
+export { ResourceInput } from './inputs/resource-input';
+export { SegmentedInput } from './inputs/segmented-input';
+export { SelectionInput } from './inputs/selection-input';
+export { TextInput } from './inputs/text-input';
+export { VectorInput } from './inputs/vector-input';
 export type { ParamEditorProps } from './param-editor';
 export { ParamEditor } from './param-editor';
+export type { ActionOption, ActionsParam, AnchorGridParam, AnchorGridValue, BaseParam, ColorParam, DateParam, FileDropParam, FileDropValue, InputGroup, NumberParam, Param, ParamEditorReadOnlyContent, ParamEditorReadOnlyImage, ParamValue, ParamValueMap, PropertyParam, RangeParam, RangeValue, ReadOnlyParam, ResourceOption, ResourceParam, ResourceRefValue, SegmentedOption, SegmentedParam, SelectionParam, TextParam, VectorParam, VectorValue, } from './param-editor.types';
+export { ParamEditorControlItem } from './param-editor-control-item';
+export { ParamEditorControlList } from './param-editor-control-list';
+export { ParamEditorField } from './param-editor-field';
+export { ParamEditorFieldLabel } from './param-editor-field-label';
+export { ParamEditorInlineGroup } from './param-editor-inline-group';
+export { ParamEditorLabel } from './param-editor-label';
+export { ParamEditorReadOnlyField } from './param-editor-read-only-field';
+export { ParamEditorReadOnlyValue } from './param-editor-read-only-value';
+export { ParamEditorSection } from './param-editor-section';

package/dist/components/param-editor/inputs/action-input.d.ts

@@ -0,0 +1,13 @@
+import { ActionOption } from '../param-editor.types';
+interface ActionInputProps {
+    id: string;
+    name: string;
+    description?: string;
+    defaultValue?: string;
+    options: ActionOption[];
+    onChange: (id: string, value: string) => void;
+    readOnly?: boolean;
+    fullWidth?: boolean;
+}
+export declare const ActionInput: (props: ActionInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/inputs/anchor-grid-input.d.ts

@@ -0,0 +1,12 @@
+import { AnchorGridValue } from '../param-editor.types';
+interface AnchorGridInputProps {
+    id: string;
+    name: string;
+    description?: string;
+    defaultValue: AnchorGridValue;
+    onChange: (id: string, value: AnchorGridValue) => void;
+    readOnly?: boolean;
+    fullWidth?: boolean;
+}
+export declare const AnchorGridInput: (props: AnchorGridInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/inputs/anchor-grid.d.ts

@@ -0,0 +1,4 @@
+import { AnchorGridValue } from '../param-editor.types';
+/** The nine anchors in row-major order (top-left → bottom-right). */
+export declare const ANCHOR_GRID_VALUES: AnchorGridValue[];
+export declare const isAnchorGridValue: (value: unknown) => value is AnchorGridValue;

package/dist/components/param-editor/inputs/file-accept.d.ts

@@ -0,0 +1,22 @@
+import { FileDropValue } from '../param-editor.types';
+interface AcceptClause {
+    kind: "extension" | "mime" | "wildcard";
+    value: string;
+}
+/** Parse an accept string ("image/*,.png,image/jpeg") into normalized clauses. */
+export declare const parseAccept: (accept?: string) => AcceptClause[];
+export interface AcceptCandidate {
+    name: string;
+    mimeType?: string;
+}
+/** Whether a file satisfies the accept string. An empty accept matches anything. */
+export declare const acceptsFile: (candidate: AcceptCandidate, accept?: string) => boolean;
+interface FileMetadataInput {
+    name: string;
+    type?: string;
+    size?: number;
+    dataUrl?: string;
+}
+/** Build the serializable metadata a file-drop control commits (never a live File). */
+export declare const fileDropValueFromFile: (input: FileMetadataInput) => FileDropValue;
+export {};

package/dist/components/param-editor/inputs/file-drop-input.d.ts

@@ -0,0 +1,14 @@
+import { FileDropValue } from '../param-editor.types';
+interface FileDropInputProps {
+    id: string;
+    name: string;
+    description?: string;
+    defaultValue: FileDropValue | null;
+    accept?: string;
+    assetKind?: "file" | "image";
+    onChange: (id: string, value: FileDropValue | null) => void;
+    readOnly?: boolean;
+    fullWidth?: boolean;
+}
+export declare const FileDropInput: (props: FileDropInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/inputs/numeric-value.d.ts

@@ -0,0 +1,6 @@
+/** Clamp `value` into the inclusive range, tolerating an inverted min/max. */
+export declare const clampToRange: (value: number, min: number, max: number) => number;
+/** Snap `value` to the nearest multiple of `step` measured from `origin`. */
+export declare const snapToStep: (value: number, step: number, origin?: number) => number;
+/** Format a number with an optional unit suffix, trimming float noise. */
+export declare const formatUnitValue: (value: number, unit?: string) => string;

package/dist/components/param-editor/inputs/range-input.d.ts

@@ -0,0 +1,17 @@
+import { RangeValue } from '../param-editor.types';
+interface RangeInputProps {
+    id: string;
+    name: string;
+    description?: string;
+    defaultValue: RangeValue;
+    min: number;
+    max: number;
+    step?: number;
+    unit?: string;
+    markerCount?: number;
+    onChange: (id: string, value: RangeValue) => void;
+    readOnly?: boolean;
+    fullWidth?: boolean;
+}
+export declare const RangeInput: (props: RangeInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/inputs/range-value.d.ts

@@ -0,0 +1,5 @@
+import { RangeValue } from '../param-editor.types';
+/** Order both handles and clamp (and optionally snap) them into `[min, max]`. */
+export declare const normalizeRange: (value: RangeValue, min: number, max: number, step?: number) => RangeValue;
+/** Replace a single handle, keeping the pair ordered. */
+export declare const updateRangeHandle: (value: RangeValue, index: 0 | 1, next: number, min: number, max: number, step?: number) => RangeValue;

package/dist/components/param-editor/inputs/resource-input-chips.d.ts

@@ -0,0 +1,15 @@
+import { ResourceOption, ResourceRefValue } from '../param-editor.types';
+interface ResourceChipProps {
+    option: ResourceOption;
+    onOpenResource?: (ref: ResourceRefValue) => void;
+    onRemove?: () => void;
+}
+export declare const ResourceChip: (props: ResourceChipProps) => import("react/jsx-runtime").JSX.Element;
+interface ResourceChipListProps {
+    options: ResourceOption[];
+    onOpenResource?: (ref: ResourceRefValue) => void;
+    onRemove?: (optionId: string) => void;
+    emptyText?: string;
+}
+export declare const ResourceChipList: (props: ResourceChipListProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/inputs/resource-input.d.ts

@@ -0,0 +1,18 @@
+import { ResourceOption, ResourceRefValue } from '../param-editor.types';
+interface ResourceInputProps {
+    id: string;
+    name: string;
+    description?: string;
+    defaultValue: string | string[];
+    options: ResourceOption[];
+    onChange: (id: string, value: string | string[]) => void;
+    onOpenResource?: (ref: ResourceRefValue) => void;
+    readOnly?: boolean;
+    editable?: boolean;
+    multiSelect?: boolean;
+    placeholder?: string;
+    emptyText?: string;
+    fullWidth?: boolean;
+}
+export declare const ResourceInput: (props: ResourceInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/inputs/segmented-input.d.ts

@@ -0,0 +1,14 @@
+import { SegmentedOption } from '../param-editor.types';
+interface SegmentedInputProps {
+    id: string;
+    name: string;
+    description?: string;
+    defaultValue: string;
+    options: SegmentedOption[];
+    variant?: "default" | "dots";
+    onChange: (id: string, value: string) => void;
+    readOnly?: boolean;
+    fullWidth?: boolean;
+}
+export declare const SegmentedInput: (props: SegmentedInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/{selection-input.d.ts → inputs/selection-input.d.ts}

@@ -1,13 +1,9 @@
-interface Option {
-    id: string;
-    name: string;
-    icon?: string;
-}
+import { SelectionMenuOption } from './selection-menu';
 interface SelectionInputProps {
     id: string;
     defaultValue: string | string[];
     name: string;
-    options: Option[];
+    options: SelectionMenuOption[];
     onChange: (id: string, value: string | string[]) => void;
     description: string;
     readOnly?: boolean;
@@ -16,6 +12,10 @@ interface SelectionInputProps {
     tooltipPlacement?: "top" | "right" | "bottom" | "left";
     placeholder?: string;
     fullWidth?: boolean;
+    /** Re-picking the selected option clears it. */
+    clearable?: boolean;
+    /** Inert, but still rendered as a control. */
+    disabled?: boolean;
 }
 export declare const SelectionInput: (props: SelectionInputProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/param-editor/inputs/selection-menu.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode } from 'react';
+export interface SelectionMenuOption {
+    id: string;
+    name: string;
+    icon?: string;
+    /** Palette key (e.g. "blue") applied to the option's icon. */
+    color?: string;
+    description?: string;
+}
+export interface SelectionMenuProps {
+    triggerLabel: ReactNode;
+    options: SelectionMenuOption[];
+    selectedIds: string[];
+    multiSelect: boolean;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    onToggle: (optionId: string) => void;
+}
+export declare const selectionIndicator: (multiSelect: boolean, selected: boolean) => import("react/jsx-runtime").JSX.Element | null;
+export declare const selectionOptionIcon: (option: SelectionMenuOption | undefined, boxSize: string) => import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The single dropdown behind every option picker in the editor — selection
+ * params and editable resource params alike. Sharing it is what keeps a
+ * resource attribute and a command param from drifting into two looks.
+ *
+ * Single-selects clear by re-picking the selected option; a dedicated "none"
+ * row would read as just another value to choose.
+ */
+export declare const SelectionMenu: (props: SelectionMenuProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/param-editor/inputs/slider-marks.d.ts

@@ -0,0 +1,5 @@
+interface SliderMarksProps {
+    count?: number;
+}
+export declare const SliderMarks: (props: SliderMarksProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/param-editor/inputs/vector-input.d.ts

@@ -0,0 +1,17 @@
+import { VectorValue } from '../param-editor.types';
+interface VectorInputProps {
+    id: string;
+    name: string;
+    description?: string;
+    defaultValue: VectorValue;
+    xLabel?: string;
+    yLabel?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    onChange: (id: string, value: VectorValue) => void;
+    readOnly?: boolean;
+    fullWidth?: boolean;
+}
+export declare const VectorInput: (props: VectorInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/inputs/vector-value.d.ts

@@ -0,0 +1,7 @@
+import { VectorValue } from '../param-editor.types';
+export interface VectorBounds {
+    min?: number;
+    max?: number;
+}
+/** Update a single axis without dropping the other, clamping into optional bounds. */
+export declare const updateVectorAxis: (value: VectorValue, axis: "x" | "y", next: number, bounds?: VectorBounds) => VectorValue;

package/dist/components/param-editor/param-editor-control-item.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+type ControlItemOrientation = "auto" | "inline" | "stacked";
+interface ParamEditorControlItemProps {
+    name?: string;
+    description?: string;
+    hideLabel?: boolean;
+    fullWidth?: boolean;
+    /** `auto` renders inline when compact and stacked when full-width. */
+    orientation?: ControlItemOrientation;
+    /** Rendered on the label row, right-aligned (e.g. an editable value readout). */
+    labelTrailing?: ReactNode;
+    children: ReactNode;
+}
+export declare const ParamEditorControlItem: (props: ParamEditorControlItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/param-editor-control-list.d.ts

@@ -0,0 +1,5 @@
+import { StackProps } from '@chakra-ui/react';
+interface ParamEditorControlListProps extends StackProps {
+}
+export declare const ParamEditorControlList: (props: ParamEditorControlListProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/param-editor-field-label.d.ts

@@ -0,0 +1 @@
+export { ParamEditorLabel as ParamEditorFieldLabel } from './param-editor-label';

package/dist/components/param-editor/param-editor-field.d.ts

@@ -0,0 +1,11 @@
+import { Param, ParamValue, ParamValueMap, ResourceRefValue } from './param-editor.types';
+interface ParamEditorFieldProps {
+    param: Param;
+    defaultValues: ParamValueMap;
+    onChange: (id: string, value: ParamValue) => void;
+    onOpenResource?: (ref: ResourceRefValue) => void;
+    readOnly?: boolean;
+    fullWidth?: boolean;
+}
+export declare const ParamEditorField: (props: ParamEditorFieldProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/param-editor/param-editor-horizontal.d.ts

@@ -6,5 +6,6 @@ export interface ParamEditorHorizontalProps {
     onChange: (id: string, value: ParamValue) => void;
     readOnly?: boolean;
     fullWidth?: boolean;
+    variant?: "default" | "small";
 }
 export declare const ParamEditorHorizontal: (props: ParamEditorHorizontalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/param-editor/param-editor-inline-group.d.ts

@@ -0,0 +1,5 @@
+import { FlexProps } from '@chakra-ui/react';
+interface ParamEditorInlineGroupProps extends FlexProps {
+}
+export declare const ParamEditorInlineGroup: (props: ParamEditorInlineGroupProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/param-editor-read-only-field.d.ts

@@ -0,0 +1,9 @@
+import { Param } from './param-editor.types';
+interface ParamEditorReadOnlyFieldProps {
+    param: Extract<Param, {
+        type: "readOnly";
+    }>;
+    fullWidth?: boolean;
+}
+export declare const ParamEditorReadOnlyField: (props: ParamEditorReadOnlyFieldProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/param-editor-section.d.ts

@@ -0,0 +1,17 @@
+import { Param, ParamValue, ParamValueMap, ResourceRefValue } from './param-editor.types';
+interface ParamEditorSectionProps {
+    title?: string;
+    description?: string;
+    params: Param[];
+    defaultValues: ParamValueMap;
+    onChange: (id: string, value: ParamValue) => void;
+    onOpenResource?: (ref: ResourceRefValue) => void;
+    readOnly?: boolean;
+    fullWidth?: boolean;
+    collapsible?: boolean;
+    defaultCollapsed?: boolean;
+    isFirst?: boolean;
+    variant?: "default" | "small";
+}
+export declare const ParamEditorSection: (props: ParamEditorSectionProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/param-editor/param-editor.d.ts

@@ -1,10 +1,12 @@
-import { InputGroup, Param, ParamValue, ParamValueMap } from './param-editor.types';
+import { InputGroup, Param, ParamValue, ParamValueMap, ResourceRefValue } from './param-editor.types';
 export interface ParamEditorProps {
     params?: Param[];
     groups?: InputGroup[];
     defaultValues?: ParamValueMap;
     onChange?: (id: string, value: ParamValue) => void;
+    onOpenResource?: (ref: ResourceRefValue) => void;
     readOnly?: boolean;
     fullWidth?: boolean;
+    variant?: "default" | "small";
 }
 export declare const ParamEditor: (props: ParamEditorProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/param-editor/param-editor.types.d.ts

@@ -3,6 +3,8 @@ export interface BaseParam {
     id: string;
     name: string;
     description?: string;
+    /** Locks this one param while the rest of the editor stays editable. */
+    readOnly?: boolean;
 }
 export interface NumberParam extends BaseParam {
     type: "number";
@@ -16,16 +18,26 @@ export interface TextParam extends BaseParam {
     defaultValue: string;
     singleLine?: boolean;
 }
+export interface SelectionOption {
+    id: string;
+    name: string;
+    icon?: string;
+    /** Palette key (e.g. "blue") applied to the option's icon. */
+    color?: string;
+}
 export interface SelectionParam extends BaseParam {
     type: "selection";
     defaultValue: string | string[];
-    options: {
-        id: string;
-        name: string;
-        icon?: string;
-    }[];
+    options: SelectionOption[];
     multiSelect?: boolean;
     placeholder?: string;
+    /** Adds a "clear" row so a single-select can be returned to unset. */
+    clearable?: boolean;
+    /**
+     * Renders the control inert but still as a control — unlike `readOnly`, which
+     * collapses it to plain text and drops the option's icon.
+     */
+    disabled?: boolean;
 }
 export interface DateParam extends BaseParam {
     type: "date";
@@ -41,20 +53,126 @@ export interface PropertyParam extends BaseParam {
     type: "property";
     value: ReactNode;
 }
-export type ObjectDefinition = (NumberParam | TextParam)[];
-export interface ObjectParam extends BaseParam {
-    type: "object";
-    defaultValue: ObjectDefinition;
-    editableSchema?: boolean;
+export interface ParamEditorReadOnlyImage {
+    src: string;
+    alt: string;
+}
+export type ParamEditorReadOnlyContent = string | number | boolean | null | Array<string | number | boolean | null> | {
+    type: "image";
+    src: string;
+    alt: string;
+} | {
+    type: "image-gallery";
+    images: ParamEditorReadOnlyImage[];
+};
+/** Serializable display-only value rendered by the read-only Param Editor. */
+export interface ReadOnlyParam extends BaseParam {
+    type: "readOnly";
+    value: ParamEditorReadOnlyContent;
+}
+/** A reference the host can open (e.g. another resource tab). */
+export interface ResourceRefValue {
+    type: string;
+    id: string;
+    label?: string;
+}
+/**
+ * Serializable resource chip. Clicking it opens `href` externally, opens `ref` via
+ * `onOpenResource`, or copies `copyText` to the clipboard — whichever is set.
+ */
+export interface ResourceOption {
+    id: string;
+    name: string;
+    icon?: string;
+    color?: string;
+    description?: string;
+    href?: string;
+    ref?: ResourceRefValue;
+    copyText?: string;
+}
+/**
+ * Resource references rendered as tags/chips. View-only by default; set `editable`
+ * to pick from `options` via a dropdown. Value is the selected option id(s), mirroring
+ * {@link SelectionParam}, so it stays JSON-safe across the controls-command boundary.
+ */
+export interface ResourceParam extends BaseParam {
+    type: "resource";
+    defaultValue: string | string[];
+    options: ResourceOption[];
+    multiSelect?: boolean;
+    editable?: boolean;
+    placeholder?: string;
+    emptyText?: string;
+}
+export type RangeValue = [number, number];
+/** Two-handle numeric range control. Values normalize to ordered `[start, end]`. */
+export interface RangeParam extends BaseParam {
+    type: "range";
+    defaultValue: RangeValue;
+    min: number;
+    max: number;
+    step?: number;
+    unit?: string;
+    markerCount?: number;
+}
+export interface SegmentedOption {
+    id: string;
+    name: string;
+    icon?: string;
+    indicatorColor?: string;
+}
+/** Mutually-exclusive mode control rendered as a segmented button group. */
+export interface SegmentedParam extends BaseParam {
+    type: "segmented";
+    defaultValue: string;
+    options: SegmentedOption[];
+    variant?: "default" | "dots";
+}
+export interface ActionOption {
+    id: string;
+    name: string;
+    icon?: string;
+    disabled?: boolean;
+}
+/** Compact command set rendered as an action button row. */
+export interface ActionsParam extends BaseParam {
+    type: "actions";
+    defaultValue?: string;
+    options: ActionOption[];
 }
-export interface ListParam extends BaseParam {
-    type: "list";
-    files?: boolean;
-    defaultValue: string[];
+export type AnchorGridValue = "top-left" | "top" | "top-right" | "left" | "center" | "right" | "bottom-left" | "bottom" | "bottom-right";
+/** Nine-point alignment picker. */
+export interface AnchorGridParam extends BaseParam {
+    type: "anchorGrid";
+    defaultValue: AnchorGridValue;
 }
+export interface VectorValue {
+    x: number;
+    y: number;
+}
+/** Paired x/y numeric control. */
 export interface VectorParam extends BaseParam {
     type: "vector";
-    defaultValue: [];
+    defaultValue: VectorValue;
+    coordinateMode?: "cartesian" | "screen";
+    xLabel?: string;
+    yLabel?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+}
+/** File selection metadata. Not a live `File` object — hosts own persistence. */
+export interface FileDropValue {
+    name: string;
+    mimeType?: string;
+    size?: number;
+    dataUrl?: string;
+}
+export interface FileDropParam extends BaseParam {
+    type: "fileDrop";
+    defaultValue: FileDropValue | null;
+    accept?: string;
+    assetKind?: "file" | "image";
 }
 export interface InputGroup {
     id: string;
@@ -64,13 +182,6 @@ export interface InputGroup {
     collapsible?: boolean;
     defaultCollapsed?: boolean;
 }
-export type ParamValue = number | string | null | ObjectDefinition | Array<number> | Array<string>;
-export type Param = NumberParam | TextParam | SelectionParam | DateParam | ColorParam | PropertyParam | ObjectParam | ListParam | VectorParam;
+export type ParamValue = number | string | null | string[] | RangeValue | VectorValue | FileDropValue;
+export type Param = NumberParam | TextParam | SelectionParam | DateParam | ColorParam | PropertyParam | ReadOnlyParam | ResourceParam | RangeParam | SegmentedParam | ActionsParam | AnchorGridParam | VectorParam | FileDropParam;
 export type ParamValueMap = Record<string, ParamValue>;
-type WithOptionalDefault<T extends {
-    defaultValue: unknown;
-}> = Omit<T, "defaultValue"> & {
-    defaultValue?: T["defaultValue"];
-};
-export type ParamConfig = WithOptionalDefault<NumberParam> | WithOptionalDefault<TextParam> | WithOptionalDefault<SelectionParam> | WithOptionalDefault<DateParam> | WithOptionalDefault<ColorParam> | WithOptionalDefault<ObjectParam> | WithOptionalDefault<ListParam> | WithOptionalDefault<VectorParam>;
-export {};