@morscherlab/mint-sdk 1.2.0-beta.1 → 1.2.0-beta.10

package/dist/composables/useListReorder.d.ts

@@ -0,0 +1,90 @@
+import { Ref } from 'vue';
+/** Inline style for a visually hidden `aria-live` region (no global utility class in the SDK). */
+export declare const REORDER_ANNOUNCER_STYLE: Readonly<{
+    position: "absolute";
+    width: "1px";
+    height: "1px";
+    padding: "0";
+    margin: "-1px";
+    overflow: "hidden";
+    clip: "rect(0, 0, 0, 0)";
+    whiteSpace: "nowrap";
+    border: "0";
+}>;
+export interface UseReorderAnnouncerReturn {
+    /** Bind to a polite live region's text content. */
+    announcement: Ref<string>;
+    /** Publishes a message to the live region. */
+    announce: (message: string) => void;
+    /** Bind to the live region's `style` so it stays visually hidden. */
+    announcerStyle: typeof REORDER_ANNOUNCER_STYLE;
+}
+/**
+ * Screen-reader announcements for drag/keyboard move interactions. Bind
+ * `announcement` to a `role="status" aria-live="polite"` element styled with
+ * `announcerStyle`.
+ */
+export declare function useReorderAnnouncer(): UseReorderAnnouncerReturn;
+export interface ListReorderMove<T> {
+    /** Index the item moved from, within `items()`. */
+    fromIndex: number;
+    /** Index the item moved to, within `items()`. */
+    toIndex: number;
+    /** The reordered array (a copy — `items()` is never mutated). */
+    items: T[];
+    /** Whether the move came from the keyboard or a pointer drag. */
+    source: 'keyboard' | 'drag';
+}
+export interface UseListReorderOptions<T> {
+    /** The list being reordered, in its canonical (not merely rendered) order. */
+    items: () => T[];
+    /** Stable id for an item; falls back to the render index when ids repeat. */
+    getId: (item: T, index: number) => string;
+    /** Applies the move. The composable never mutates the source array. */
+    onReorder: (move: ListReorderMove<T>) => void;
+    /** Human-readable name used in announcements. Defaults to the item's id. */
+    getLabel?: (item: T, index: number) => string;
+    /** Blocks every reorder while it returns `true` (readonly / non-sortable lists). */
+    disabled?: () => boolean;
+    /** Resolves the focusable element for an id so keyboard moves keep focus on the item. */
+    getElement?: (id: string) => HTMLElement | null | undefined;
+    /** Noun used in announcements, e.g. `'Reagent'`. Default `'Item'`. */
+    itemNoun?: string;
+}
+export interface UseListReorderReturn<T> {
+    /** Id of the item currently being dragged, or `null`. */
+    draggingId: Ref<string | null>;
+    /** Id of the item the pointer is hovering as a drop target, or `null`. */
+    dragOverId: Ref<string | null>;
+    isDragging: (id: string) => boolean;
+    isDragOver: (id: string) => boolean;
+    announcement: Ref<string>;
+    announcerStyle: typeof REORDER_ANNOUNCER_STYLE;
+    announce: (message: string) => void;
+    /** Bind to the draggable element's `@dragstart`. */
+    onDragStart: (event: DragEvent, item: T, index: number) => void;
+    /** Bind to `@dragover` — calls `preventDefault()` so the drop is accepted. */
+    onDragOver: (event: DragEvent, item: T, index: number) => void;
+    /** Bind to `@dragleave`. */
+    onDragLeave: () => void;
+    /** Bind to `@drop`. */
+    onDrop: (event: DragEvent, item: T, index: number) => void;
+    /** Bind to `@dragend`. */
+    onDragEnd: () => void;
+    /**
+     * Bind to the item's (or its drag handle's) `@keydown`: Alt+ArrowUp / Alt+ArrowLeft
+     * moves the item one position earlier, Alt+ArrowDown / Alt+ArrowRight one later.
+     */
+    onKeydown: (event: KeyboardEvent, item: T, index: number) => void;
+    /** Moves an item between two indices of `items()` programmatically. */
+    move: (fromIndex: number, toIndex: number, source?: 'keyboard' | 'drag') => void;
+}
+/** Pure helper: a copy of `items` with the entry at `from` moved to `to`. */
+export declare function reorderList<T>(items: T[], from: number, to: number): T[];
+/**
+ * Keyboard-accessible list reordering shared by the SDK's drag-to-reorder lists.
+ * It owns the HTML5 drag state, the drop-index maths, and an Alt+Arrow keyboard
+ * alternative that announces every move through a polite live region — so a
+ * reorder never depends on a pointer.
+ */
+export declare function useListReorder<T>(options: UseListReorderOptions<T>): UseListReorderReturn<T>;

package/dist/composables/useMenuKeyboard.d.ts

@@ -0,0 +1,29 @@
+export interface UseMenuKeyboardOptions {
+    /** Returns the currently navigable items inside the open panel, in DOM order. */
+    items: () => HTMLElement[];
+    /** True while the panel is open. */
+    isOpen: () => boolean;
+    /** Opens the panel. */
+    open: () => void;
+    /** Closes the panel. When `returnFocus` is true, focus should return to the trigger. */
+    close: (returnFocus?: boolean) => void;
+}
+export interface UseMenuKeyboardReturn {
+    /**
+     * Bind to the trigger's `@keydown`. ArrowDown/Enter/Space open the panel (when
+     * closed) and focus its first item; ArrowUp opens it focused on the last item.
+     */
+    handleTriggerKeydown: (event: KeyboardEvent) => void;
+    /**
+     * Bind to the open panel's `@keydown`. ArrowUp/ArrowDown cycle focus with
+     * wraparound, Home/End jump to the first/last item, Escape closes and returns
+     * focus to the trigger, and Tab closes without moving focus.
+     */
+    handlePanelKeydown: (event: KeyboardEvent) => void;
+}
+/**
+ * Shared keyboard contract for menu- and listbox-style disclosure panels (the
+ * WAI-ARIA menu button pattern). Used by ActionMenu, AppAvatarMenu and DropdownButton,
+ * each pairing it with `useDropdownState` for the disclosure state itself.
+ */
+export declare function useMenuKeyboard(options: UseMenuKeyboardOptions): UseMenuKeyboardReturn;

package/dist/composables/useOptimisticMutation.d.ts

@@ -24,5 +24,9 @@ export interface UseOptimisticMutationReturn<TVariables, TData, TSnapshot = unkn
     clearError: () => void;
     reset: () => void;
 }
-/** Run async mutations with optional optimistic local updates and rollback. */
+/**
+ * Run async mutations with optional optimistic local updates and rollback.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useRequestSyncState()` instead.
+ */
 export declare function useOptimisticMutation<TVariables, TData, TSnapshot = unknown>(options: UseOptimisticMutationOptions<TVariables, TData, TSnapshot>): UseOptimisticMutationReturn<TVariables, TData, TSnapshot>;

package/dist/composables/usePluginClient.d.ts

@@ -209,6 +209,8 @@ export declare function createPluginClient<TClient extends object = GeneratedPlu
 export declare function uploadPluginEndpoint<TResponse = unknown>(contract: PluginContract, endpoint: PluginEndpointDefinition, payload?: unknown, options?: PluginEndpointRequestOptions): Promise<TResponse>;
 /** Fetch a generated plugin endpoint as a Blob and optionally trigger a browser download. */
 export declare function downloadPluginEndpoint(contract: PluginContract, endpoint: PluginEndpointDefinition, payload?: unknown, options?: DownloadPluginEndpointOptions): Promise<Blob>;
+/** @deprecated Use `useGeneratedPluginClient()` for generated clients. */
+export declare function usePluginClient<TClient>(client: TClient): TClient;
 /** Load, edit, and persist plugin settings from platform config or the plugin-local settings router. */
 export declare function usePluginSettings<TSettings = Record<string, unknown>>(options?: UsePluginSettingsOptions | string): UsePluginSettingsReturn<TSettings>;
 /** Consume a generated plugin SSE endpoint with auth headers, reconnect, and teardown. */

package/dist/composables/usePluginConfig.d.ts

@@ -0,0 +1,27 @@
+import { Ref, ComputedRef } from 'vue';
+export interface UsePluginConfigReturn {
+    /** Editable plugin configuration values. */
+    config: Ref<Record<string, unknown>>;
+    /** Whether the config is currently loading. */
+    isLoading: Ref<boolean>;
+    /** Whether the config is currently saving. */
+    isSaving: Ref<boolean>;
+    /** Error message from the last failed operation, or null. */
+    error: Ref<string | null>;
+    /** Timestamp of the last successful load, or null. */
+    lastLoadedAt: Ref<Date | null>;
+    /** Timestamp of the last successful save, or null. */
+    lastSavedAt: Ref<Date | null>;
+    /** Whether local config differs from the last loaded or saved snapshot. */
+    isDirty: ComputedRef<boolean>;
+    /** Load plugin configuration from the platform. */
+    load: () => Promise<void>;
+    /** Save plugin configuration to the platform. */
+    save: () => Promise<boolean>;
+    /** Restore the last loaded or saved configuration snapshot. */
+    reset: () => void;
+}
+/**
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `usePluginSettings()` for typed plugin settings.
+ */
+export declare function usePluginConfig(pluginName?: string): UsePluginConfigReturn;

package/dist/composables/usePluginWorkspace.d.ts

@@ -0,0 +1,51 @@
+import { ComputedRef } from 'vue';
+import { PageSelectorItem, PillNavItem } from '../types';
+import { PluginWorkspaceViewEmit, PluginWorkspaceViewProps } from '../components/PluginWorkspaceView.props';
+import { PluginWorkspaceControlsModel, PluginWorkspaceShellModel, PluginWorkspaceSidebarModel } from './pluginWorkspaceModel';
+/**
+ * Loosely-typed view of a component's `useSlots()` result: only slot presence and names are
+ * read here, so this accepts any `defineSlots()` shape without fighting Vue's `Slot` render
+ * function type. Mirrors the `SlotKeyMap` helper type in PluginWorkspaceView.shell.ts.
+ */
+export type PluginWorkspaceSlotsLike = Readonly<Record<string, unknown>>;
+export interface UsePluginWorkspaceOptions {
+    /** PluginWorkspaceView's own reactive props object (from `defineProps`). */
+    props: PluginWorkspaceViewProps;
+    /** PluginWorkspaceView's own slots (from `useSlots()`), used to detect provided passthrough slots. */
+    slots: PluginWorkspaceSlotsLike;
+    /** PluginWorkspaceView's own typed `emit` function (from `defineEmits<PluginWorkspaceViewEmits>()`). */
+    emit: PluginWorkspaceViewEmit;
+}
+export interface UsePluginWorkspaceReturn {
+    /** Model consumed by WorkspaceShellInternal's `shell` prop. */
+    shell: ComputedRef<PluginWorkspaceShellModel>;
+    /** Model consumed by WorkspaceSidebarInternal's `sidebar` prop. */
+    sidebar: ComputedRef<PluginWorkspaceSidebarModel>;
+    /** Model consumed by WorkspaceControlsInternal's `controls` prop, and by the raw `default` slot. */
+    controls: ComputedRef<PluginWorkspaceControlsModel>;
+    /** Whether AppLayout should render a sidebar surface at all. */
+    hasSidebarSurface: ComputedRef<boolean>;
+    /** Applies an AppSidebar `update:model-value` payload to the shared control values and emits `update:modelValue`/`update:values`. */
+    handleControlValuesUpdate: (values: Record<string, unknown>) => void;
+    /** Resolves an AppTopBar `page-selector-select` payload into the active view and emits `page-selector-select`. */
+    handlePageSelectorSelect: (page: PageSelectorItem) => void;
+    /** Resolves an AppTopBar `pill-select` payload into the active view and emits `pill-select`. */
+    handlePillSelect: (item: PillNavItem) => void;
+}
+/**
+ * Maps PluginWorkspaceView's flat 72-prop surface into the three typed model objects
+ * (`shell`, `sidebar`, `controls`) rendered by its internal pieces
+ * (WorkspaceShellInternal, WorkspaceSidebarInternal, WorkspaceControlsInternal). Reuses the
+ * existing `usePluginWorkspaceControls` / `usePluginWorkspaceNavigation` composables and the
+ * PluginWorkspaceView.shell slot-detection helpers, so it changes only how that state is
+ * assembled and exposed, not the underlying behavior.
+ *
+ * @example Recommended
+ * ```ts
+ * const props = withDefaults(defineProps<PluginWorkspaceViewProps>(), { ... })
+ * const emit = defineEmits<PluginWorkspaceViewEmits>()
+ * const slots = useSlots()
+ * const { shell, sidebar, controls } = usePluginWorkspace({ props, slots, emit })
+ * ```
+ */
+export declare function usePluginWorkspace(options: UsePluginWorkspaceOptions): UsePluginWorkspaceReturn;

package/dist/composables/useRequestSyncState.d.ts

@@ -1,8 +1,24 @@
 import { Ref } from 'vue';
 export type RequestSyncSuccessKind = 'load' | 'save' | 'run';
+/**
+ * The unit of work `run()` drives.
+ *
+ * It receives an `AbortSignal` that fires when the run is superseded by a
+ * newer `run()` or by `cancel()`. Zero-argument operations stay valid and
+ * simply ignore it.
+ */
+export type RequestSyncOperation<T> = (signal: AbortSignal) => Promise<T>;
 export interface RequestSyncRunOptions {
     success?: RequestSyncSuccessKind;
     errorMessage?: string;
+    /**
+     * Abort the previously started run when this one starts. Default `true`;
+     * pass `false` to let overlapping runs finish their own work (the stale
+     * guard on shared state still applies either way).
+     */
+    abortPrevious?: boolean;
+    /** Caller-owned signal; aborting it aborts this run's signal too. */
+    signal?: AbortSignal;
 }
 export interface UseRequestSyncStateReturn {
     /** Whether a request is in progress. */
@@ -27,8 +43,32 @@ export interface UseRequestSyncStateReturn {
     markSaved: (date?: Date) => void;
     /** Mark the operation as successfully run. */
     markRun: (date?: Date) => void;
-    /** Run a request with shared loading/error handling and optional sync marking. */
-    run: <T>(operation: () => Promise<T>, options?: RequestSyncRunOptions) => Promise<T>;
+    /**
+     * Run a request with shared loading/error handling and optional sync marking.
+     *
+     * ## Stale-response semantics
+     *
+     * Every call takes a monotonically increasing token. Starting a run
+     * supersedes any run started before it, and a superseded run writes **no**
+     * shared state when it finally settles: it does not clear `loading`, does not
+     * set `error`, and does not move `lastLoadedAt` / `lastSavedAt` / `lastRunAt`.
+     * Only the newest run owns those.
+     *
+     * The caller's own promise is untouched by the guard — a superseded run still
+     * resolves with its value or rejects with its own error, exactly as the
+     * operation did. The guard never invents a rejection, so a caller awaiting
+     * `run()` never sees a "superseded" error it did not cause.
+     *
+     * The operation additionally receives an `AbortSignal` that fires when its
+     * run is superseded or `cancel()` is called, so an operation that forwards
+     * the signal (`fetch(url, { signal })`) stops work instead of racing.
+     */
+    run: <T>(operation: RequestSyncOperation<T>, options?: RequestSyncRunOptions) => Promise<T>;
+    /**
+     * Abort the in-flight run and drop `loading`. The aborted run's completion
+     * is treated as stale and writes no state.
+     */
+    cancel: () => void;
 }
 /** Shared loading/error/timestamp state for generated plugin request helpers. */
 export declare function useRequestSyncState(defaultErrorMessage?: string): UseRequestSyncStateReturn;

package/dist/composables/useResourceCrud.d.ts

@@ -28,7 +28,11 @@ export interface UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey extends Res
     removeLocal: (keyOrItem: TKey | TItem) => void;
     clearError: () => void;
 }
-/** Common list/create/update/delete state wrapper for generated plugin clients. */
+/**
+ * Common list/create/update/delete state wrapper for generated plugin clients.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useGeneratedPluginClient()` instead.
+ */
 export declare function useResourceCrud<TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey>(options: UseResourceCrudOptions<TItem, TCreate, TUpdate, TKey>): UseResourceCrudReturn<TItem, TCreate, TUpdate, TKey>;
 export interface PluginResourceClientOptions<TClient, TItem, TCreate = Partial<TItem>, TUpdate = Partial<TItem>, TKey extends ResourceKey = ResourceKey> {
     client: TClient;

package/dist/composables/useRovingFocus.d.ts

@@ -0,0 +1,24 @@
+export interface UseRovingFocusOptions {
+    /** Selectable item ids, in DOM order. Already excludes items skipped entirely (e.g. disabled tabs). */
+    ids: () => string[];
+    /** The id that is currently active/selected. */
+    activeId: () => string | undefined;
+    /** Activates an id (e.g. emit `update:modelValue`). The composable focuses the matching element afterward. */
+    activate: (id: string) => void;
+    /** Returns the focusable element for an id, queried lazily so it reflects the post-activation DOM. */
+    getElement: (id: string) => HTMLElement | null | undefined;
+    /** Arrow-key axis: `'horizontal'` (Left/Right, default) or `'vertical'` (Up/Down). */
+    orientation?: 'horizontal' | 'vertical';
+}
+export interface UseRovingFocusReturn {
+    /** Bind to each item's `@keydown`. */
+    handleKeydown: (event: KeyboardEvent) => void;
+}
+/**
+ * WAI-ARIA roving-tabindex navigation with automatic activation (the tabs pattern):
+ * Left/Right (or Up/Down when `orientation` is `'vertical'`) move to the adjacent item
+ * and activate it immediately, wrapping past the ends; Home/End jump to the first/last
+ * item. Only the active item should carry `tabindex="0"`; give every other item
+ * `tabindex="-1"`. Used by BaseTabs.
+ */
+export declare function useRovingFocus(options: UseRovingFocusOptions): UseRovingFocusReturn;

package/dist/composables/useScheduleDrag.d.ts

@@ -75,4 +75,5 @@ export declare function useScheduleDrag(options: UseScheduleDragOptions): {
     startCreate: (date: Date, y: number, dayIndex: number) => void;
     startMove: (event: ScheduleEvent, y: number, dayIndex: number) => void;
     startResize: (event: ScheduleEvent, edge: "top" | "bottom", y: number, dayIndex: number) => void;
+    nudgeEvent: (event: ScheduleEvent, direction: -1 | 1, mode?: "move" | "resize") => boolean;
 };

package/dist/composables/useWellPainting.d.ts

@@ -28,7 +28,11 @@ export interface UseWellPaintingReturn<TMode extends string = string, TPayload =
     onWellMouseUp: () => void;
     cancel: () => void;
 }
-/** Pointer painting/rectangle selection state for WellPlate-based editors. */
+/**
+ * Pointer painting/rectangle selection state for WellPlate-based editors.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export declare function useWellPainting<TMode extends string = string, TPayload = unknown>(options: UseWellPaintingOptions<TMode, TPayload>): UseWellPaintingReturn<TMode, TPayload>;
 export declare function wellIdToCoordinate(wellId: string): WellCoordinate | null;
 export declare function coordinateToWellId(coord: WellCoordinate): string;

package/dist/composables/useWellPlateAdapter.d.ts

@@ -19,7 +19,11 @@ export interface WellPlateAdapterOptions<TEntry> {
 export interface UseWellPlateAdapterReturn {
     wells: ComputedRef<Record<string, Partial<Well>>>;
 }
-/** Convert domain rows into WellPlate's wells prop without hand-written adapters. */
+/**
+ * Convert domain rows into WellPlate's wells prop without hand-written adapters.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export declare function useWellPlateAdapter<TEntry>(options: WellPlateAdapterOptions<TEntry>): UseWellPlateAdapterReturn;
 export declare function createWellPlateWells<TEntry>(entries: readonly TEntry[], options: Omit<WellPlateAdapterOptions<TEntry>, 'entries'>): Record<string, Partial<Well>>;
 export interface AxisConditionEntry {

package/dist/composables/useWellPlateValidation.d.ts

@@ -22,6 +22,10 @@ export interface UseWellPlateValidationReturn<TType extends string = string> {
     warningCount: ComputedRef<number>;
     errorCount: ComputedRef<number>;
 }
-/** Rule-driven validation state for WellPlate layout/design screens. */
+/**
+ * Rule-driven validation state for WellPlate layout/design screens.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useWellPlateEditor()` instead.
+ */
 export declare function useWellPlateValidation<TContext, TType extends string = string>(options: UseWellPlateValidationOptions<TContext, TType>): UseWellPlateValidationReturn<TType>;
 export declare function runWellPlateValidation<TContext, TType extends string = string>(context: TContext, rules: readonly WellPlateValidationRule<TContext, TType>[]): WellPlateValidationWarning<TType>[];

package/dist/composables/workspaceRecipes.d.ts

@@ -0,0 +1,188 @@
+import { TopBarVariant } from '../types';
+import { FormEnhancements } from '../types/form-builder';
+import { ControlModel, ControlModelBinding, ControlSchema, ControlWorkspaceOptions, UseControlWorkspaceReturn } from './useControlSchema';
+/**
+ * Merges `initialValues`/external `modelValue`/`values` on top of a base
+ * `ControlWorkspaceOptions.initialValues`, matching the layering FormBuilder expects: base
+ * defaults, then caller-supplied initial values, then live external values win last. Shared by
+ * {@link controlWorkspaceProps} and {@link bioTemplatePresetWorkspaceProps} so both "generate a
+ * workspace from options, initialValues, and v-model" views merge options identically.
+ */
+export declare function resolveControlOptionsWithExternalValues<TOptions extends ControlWorkspaceOptions>(base: TOptions, initialValues: Record<string, unknown> | undefined, externalValues: Record<string, unknown> | undefined): TOptions;
+export interface ControlWorkspaceModelProps {
+    model?: ControlModel | ControlModelBinding;
+    controls?: ControlSchema;
+    controlOptions?: ControlWorkspaceOptions;
+    initialValues?: Record<string, unknown>;
+    modelValue?: Record<string, unknown>;
+    values?: Record<string, unknown>;
+}
+export interface ResolvedControlWorkspaceModel {
+    /** `modelValue` if provided, else `values` — the single external v-model source of truth. */
+    externalValues: Record<string, unknown> | undefined;
+    /** `model` resolved through `resolveControlModel()`, or undefined for a raw `controls` schema. */
+    resolvedModel: ControlModelBinding | undefined;
+    /** `controls` if provided, else the resolved model's controls, else `{}`. */
+    resolvedControls: ControlSchema;
+    /** `controlOptions` merged over the resolved model's own options, with initialValues/external values layered on top. */
+    resolvedControlOptions: ControlWorkspaceOptions;
+}
+/**
+ * Resolves ControlWorkspaceView's `model`/`controls`/`controlOptions`/`initialValues`/
+ * `modelValue`/`values` props into the schema + options pair `useControlWorkspace()` needs.
+ * Pure and framework-free so callers wrap each field in their own `computed()`.
+ *
+ * @example Recommended
+ * ```ts
+ * const resolved = computed(() => controlWorkspaceProps(props))
+ * const resolvedControls = computed(() => resolved.value.resolvedControls)
+ * ```
+ */
+export declare function controlWorkspaceProps(props: ControlWorkspaceModelProps): ResolvedControlWorkspaceModel;
+export interface DoseDesignWorkspacePassthroughProps {
+    workspace?: UseControlWorkspaceReturn<ControlSchema>;
+    controlOptions?: ControlWorkspaceOptions;
+    initialValues?: Record<string, unknown>;
+    modelValue?: Record<string, unknown>;
+    values?: Record<string, unknown>;
+    title?: string;
+    subtitle?: string;
+    topBarVariant?: TopBarVariant;
+    sidebarWidth?: string;
+    sidebarVariant?: 'default' | 'analysis';
+    responsiveSidebar?: boolean;
+    sidebarPosition?: 'left' | 'right';
+    sidebarTitle?: string;
+    sidebarSubtitle?: string;
+    sidebarBadge?: string | number;
+    floating?: boolean;
+    dense?: boolean;
+    showSettings?: boolean;
+    showFormActions?: boolean;
+    formEnhancements?: FormEnhancements<Record<string, unknown>>;
+    formLoading?: boolean;
+    formDisabled?: boolean;
+    formReadonly?: boolean;
+    formSize?: 'sm' | 'md' | 'lg';
+}
+/**
+ * Maps DoseDesignWorkspaceView's props straight through to the identically-named
+ * ControlWorkspaceView props it wraps — the ~25-key pass-through list that used to be spelled
+ * out attribute-by-attribute in the template. `model` is the caller's already-resolved dose
+ * design model, not the raw (possibly absent) `props.model`.
+ *
+ * @example Recommended
+ * ```vue
+ * <ControlWorkspaceView v-bind="doseDesignWorkspaceProps(props, resolvedModel)" />
+ * ```
+ */
+export declare function doseDesignWorkspaceProps(props: DoseDesignWorkspacePassthroughProps, model: ControlModel | ControlModelBinding): {
+    model: ControlModel | ControlModelBinding;
+    workspace: UseControlWorkspaceReturn<ControlSchema> | undefined;
+    controlOptions: ControlWorkspaceOptions | undefined;
+    initialValues: Record<string, unknown> | undefined;
+    modelValue: Record<string, unknown> | undefined;
+    values: Record<string, unknown> | undefined;
+    title: string | undefined;
+    subtitle: string | undefined;
+    topBarVariant: TopBarVariant | undefined;
+    sidebarWidth: string | undefined;
+    sidebarVariant: "default" | "analysis" | undefined;
+    responsiveSidebar: boolean | undefined;
+    sidebarPosition: "left" | "right" | undefined;
+    sidebarTitle: string | undefined;
+    sidebarSubtitle: string | undefined;
+    sidebarBadge: string | number | undefined;
+    floating: boolean | undefined;
+    dense: boolean | undefined;
+    showSettings: boolean | undefined;
+    showFormActions: boolean | undefined;
+    formEnhancements: FormEnhancements<Record<string, unknown>> | undefined;
+    formLoading: boolean | undefined;
+    formDisabled: boolean | undefined;
+    formReadonly: boolean | undefined;
+    formSize: "sm" | "md" | "lg" | undefined;
+};
+export interface BioTemplateExperimentWorkspaceStatusProps {
+    status?: {
+        loading?: boolean;
+        saving?: boolean;
+        error?: string | null;
+        hasExperiment?: boolean;
+        currentExperimentId?: number;
+        lastLoadedAt?: Date | null;
+        lastSavedAt?: Date | null;
+    };
+    loading?: boolean;
+    error?: string | null;
+    hasExperiment?: boolean;
+    currentExperimentId?: number;
+    lastLoadedAt?: Date | null;
+    lastSavedAt?: Date | null;
+}
+export interface ResolvedBioTemplateExperimentStatus {
+    loading: boolean;
+    error: string | null | undefined;
+    hasExperiment: boolean;
+    currentExperimentId: number | undefined;
+    lastLoadedAt: Date | null | undefined;
+    lastSavedAt: Date | null | undefined;
+}
+/**
+ * Merges BioTemplateExperimentWorkspaceView's grouped `status` prop over its individual
+ * `loading`/`error`/`hasExperiment`/... props: `status` wins whenever the corresponding field
+ * on it is set, otherwise the flat prop (or its default) is used. Centralizes the six
+ * independent fallback rules generated plugin pages rely on when they pass a request/experiment
+ * `status` object instead of wiring each field by hand.
+ */
+export declare function bioTemplateExperimentWorkspaceProps(props: BioTemplateExperimentWorkspaceStatusProps): ResolvedBioTemplateExperimentStatus;
+export interface BioTemplatePackWorkspacePassthroughProps {
+    message?: string;
+    dense?: boolean;
+    readonly?: boolean;
+    showStatus?: boolean;
+    showTemplateSummary?: boolean;
+    loadLabel?: string;
+    resetLabel?: string;
+    saveLabel?: string;
+}
+/**
+ * Assembles the prop object BioTemplatePackWorkspaceView binds onto the
+ * BioTemplateExperimentWorkspaceView it wraps: its own display props passed straight through,
+ * plus the pack-derived `target`/`label`/`status`/`actions` computed by the caller.
+ */
+export declare function bioTemplatePackWorkspaceProps<TTarget, TStatus, TActions>(props: BioTemplatePackWorkspacePassthroughProps, derived: {
+    target: TTarget;
+    label: string;
+    status: TStatus;
+    actions: TActions;
+}): {
+    target: TTarget;
+    kind: "collection";
+    label: string;
+    message: string | undefined;
+    status: TStatus;
+    actions: TActions;
+    dense: boolean | undefined;
+    readonly: boolean | undefined;
+    showStatus: boolean | undefined;
+    showTemplateSummary: boolean | undefined;
+    loadLabel: string | undefined;
+    resetLabel: string | undefined;
+    saveLabel: string | undefined;
+};
+export interface BioTemplatePresetWorkspaceOptionsProps<TOptions extends ControlWorkspaceOptions> {
+    workspaceOptions?: TOptions;
+    initialValues?: Record<string, unknown>;
+    modelValue?: Record<string, unknown>;
+    values?: Record<string, unknown>;
+}
+/**
+ * Resolves BioTemplatePresetWorkspaceView's `workspaceOptions`/`initialValues`/`modelValue`/
+ * `values` props into the single options object `useBioTemplatePresetWorkspace()` needs,
+ * reusing the same base/initialValues/external-values layering as {@link controlWorkspaceProps}.
+ */
+export declare function bioTemplatePresetWorkspaceProps<TOptions extends ControlWorkspaceOptions>(props: BioTemplatePresetWorkspaceOptionsProps<TOptions>): {
+    externalValues: Record<string, unknown> | undefined;
+    resolvedWorkspaceOptions: TOptions;
+};