@overvis/hmi-workspace-ui 0.0.0-stage → 0.1.0

package/dist/src/workspace/parameters/option-labels.d.ts

@@ -0,0 +1,14 @@
+import { DATETIME_COMPOSITION_KINDS, GEO_PACKINGS, INT_BYTE_PACKINGS, NUMERIC_PACKINGS, STR_ENCODINGS, VALUE_TYPE_NAMES } from "./form/values.js";
+export declare function modbusTableLabel(table: "holding-register" | "input-register" | "coil" | "discrete-input"): string;
+export declare function modbusWriteFunctionLabel(writeFunction: "none" | "single-write" | "multi-or-single-write" | "always-multi-write"): string;
+export declare function calcReturnFormatLabel(format: "float" | "int"): string;
+export declare function byteSwapLabel(swap: "bytes" | "words"): string;
+export declare function filterBytesLabel(filter: "leave-first-byte-in-word" | "leave-last-byte-in-word"): string;
+export declare function valueTypeNameLabel(name: (typeof VALUE_TYPE_NAMES)[number]): string;
+export declare function strEncodingLabel(encoding: (typeof STR_ENCODINGS)[number]): string;
+type PackingId = (typeof NUMERIC_PACKINGS)[number] | (typeof INT_BYTE_PACKINGS)[number] | (typeof GEO_PACKINGS)[number];
+export declare function packingLabel(packing: PackingId): string;
+export declare function datetimeCompositionKindLabel(kind: (typeof DATETIME_COMPOSITION_KINDS)[number]): string;
+export declare function ipVariantLabel(variant: "ipv4" | "ipv6"): string;
+export declare function timezoneOffsetUnitLabel(unit: "hours" | "minutes" | "seconds"): string;
+export {};

package/dist/src/workspace/parameters/picker/browser.d.ts

@@ -0,0 +1,41 @@
+import { type ReactNode, type RefObject } from "react";
+import { type PickerIndex } from "./model.js";
+/**
+ * Branches open when the browser first shows: those leading to the first selected parameter, or
+ * else a lone root and any lone branches below it.
+ */
+export declare function initialPickerExpanded(index: PickerIndex, selectedId: string | null): Set<string>;
+/**
+ * A branch path on one line. Each branch truncates on its own and the outer ones give way first,
+ * so the branch nearest the parameter stays readable in a narrow field.
+ */
+export declare function PickerPath({ path, tokens, className, }: {
+    path: readonly string[];
+    tokens?: readonly string[];
+    className?: string;
+}): import("react").JSX.Element;
+/**
+ * Search and browse the workspace parameters: with an empty search, the Setup tree to open branch
+ * by branch; while searching, matching parameters with the branches they are in. The search box
+ * keeps focus, and the arrow keys, Enter and, with several selected, Space work the list.
+ */
+export declare function ParameterBrowser({ index, loading, selectedIds, multiple, preferred, onPick, onToggle, emptyText, inputRef, className, footer, }: {
+    index: PickerIndex;
+    loading: boolean;
+    selectedIds: ReadonlySet<string>;
+    /** Check any number of parameters instead of picking one. */
+    multiple?: boolean;
+    /** Parameters this returns true for are listed first among search results. */
+    preferred?: ((parameterId: string) => boolean) | undefined;
+    /** One parameter was picked. */
+    onPick?: (parameterId: string) => void;
+    /** Parameters were checked or unchecked, with several selectable. */
+    onToggle?: (parameterIds: readonly string[], selected: boolean) => void;
+    /** Shown when there is nothing to pick from at all. */
+    emptyText?: ReactNode;
+    /** The search box, for a popup to focus when it opens. */
+    inputRef?: RefObject<HTMLInputElement | null>;
+    className?: string;
+    /** Below the list, such as a dialog's count of checked parameters. */
+    footer?: ReactNode;
+}): import("react").JSX.Element;

package/dist/src/workspace/parameters/picker/model.d.ts

@@ -0,0 +1,91 @@
+import type { ParameterTreeBranch, ParameterWithReadings } from "@overvis/hmi-shared/parameter";
+/** A parameter as the picker shows and searches it, with texts in the UI language. */
+export interface PickerParameter {
+    id: string;
+    branchId: string;
+    name: string;
+    mnemonic: string | null;
+    units: string | null;
+    /** Where the value comes from, such as `hold 1024`; null for a calculated parameter. */
+    address: string | null;
+    /** Branch names from the root down to the parameter's own branch. */
+    path: readonly string[];
+    disabled: boolean;
+    valueTypeName: ParameterWithReadings["valueType"]["name"];
+    /** Position in the Setup tree, for a stable order of equally good matches. */
+    order: number;
+    /** Lowercased names and mnemonics in every language, then the path and address. */
+    haystack: string;
+}
+export interface PickerBranch {
+    id: string;
+    parentId: string | null;
+    name: string;
+}
+export interface PickerIndex {
+    parameters: ReadonlyMap<string, PickerParameter>;
+    /** Listed parameters in Setup tree order. */
+    listed: readonly PickerParameter[];
+    branches: ReadonlyMap<string, PickerBranch>;
+    childBranches: ReadonlyMap<string | null, readonly PickerBranch[]>;
+    branchParameters: ReadonlyMap<string, readonly PickerParameter[]>;
+    /** Listed parameters anywhere under each branch. */
+    subtreeParameterIds: ReadonlyMap<string, readonly string[]>;
+}
+export type PickerRow = {
+    kind: "branch";
+    key: string;
+    id: string;
+    name: string;
+    depth: number;
+    count: number;
+    open: boolean;
+} | {
+    kind: "parameter";
+    key: string;
+    parameter: PickerParameter;
+    depth: number;
+};
+export interface PickerSearchResult {
+    rows: PickerRow[];
+    /** Matches beyond the shown rows. */
+    hidden: number;
+    /** Ids of every match, shown or not. */
+    matchIds: string[];
+}
+/**
+ * Index the workspace tree for picking. Disabled parameters, unless `includeDisabled`, and those
+ * `include` rejects are not listed, but stay known so a field can still name the parameter it
+ * already holds; branches without listed parameters are left out.
+ */
+export declare function buildPickerIndex(input: {
+    branches: readonly ParameterTreeBranch[];
+    parameters: readonly ParameterWithReadings[];
+    locale: string;
+    include?: ((parameter: ParameterWithReadings) => boolean) | undefined;
+    /** List disabled parameters too, such as for a report of their recorded history. */
+    includeDisabled?: boolean | undefined;
+}): PickerIndex;
+/** Rows of the browsable tree: branches, and the parameters of every open branch. */
+export declare function pickerTreeRows(index: PickerIndex, expanded: ReadonlySet<string>): PickerRow[];
+/** The branches that must be open for the parameter to show, root first. */
+export declare function pickerAncestorIds(index: PickerIndex, parameterId: string): string[];
+/** The branch and every listed branch below it. */
+export declare function pickerSubtreeBranchIds(index: PickerIndex, branchId: string): string[];
+/**
+ * Parameters whose names, mnemonics, branch path or address contain every word of the query,
+ * best first: the query as the name or mnemonic, or its start, then by how many words match the
+ * name or mnemonic as whole words, word starts or parts, and shorter names first. `preferred` ones
+ * come before the rest; matches through the path alone keep the Setup tree order.
+ */
+export declare function searchPicker(index: PickerIndex, query: string, options: {
+    limit: number;
+    preferred?: ((parameterId: string) => boolean) | undefined;
+}): PickerSearchResult;
+/** Pieces of `text` with the parts that match a query word marked, for highlighting. */
+export declare function highlightParts(text: string, tokens: readonly string[]): {
+    text: string;
+    match: boolean;
+}[];
+/** Whether a branch's listed parameters are all, some or none of the selection. */
+export declare function pickerBranchCheck(index: PickerIndex, branchId: string, selected: ReadonlySet<string>): boolean | "indeterminate";

package/dist/src/workspace/parameters/picker/picker.d.ts

@@ -0,0 +1,380 @@
+import { type ReactNode } from "react";
+import type { ParameterWithReadings } from "@overvis/hmi-shared/parameter";
+/** The workspace parameters indexed for picking, texts in the UI language. */
+export declare function useParameterPickerIndex(workspaceId: string, options?: {
+    include?: (parameter: ParameterWithReadings) => boolean;
+    includeDisabled?: boolean;
+}): {
+    index: import("./model.js").PickerIndex;
+    loading: boolean;
+    parameters: {
+        id: string;
+        workspaceId: string;
+        branchId: string;
+        name: string | Record<string, string>;
+        description: string | Record<string, string> | null;
+        icon: string | null;
+        units: string | Record<string, string> | null;
+        mnemonic: string | Record<string, string> | null;
+        tags: string[];
+        source: {
+            kind: "const";
+            key: string;
+            allowWrite: boolean;
+        } | {
+            kind: "calc";
+            inputParamIds: string[];
+            formula: string;
+            returnFormat: "float" | "int";
+        } | {
+            kind: "modbus-tcp";
+            endpointId: string;
+            unitId: number;
+            table: "coil" | "holding-register";
+            addresses: number[];
+            writeFunction: "always-multi-write" | "multi-or-single-write" | "none" | "single-write";
+            read?: {
+                allowMultiRead?: boolean;
+                maxQuantityPerRequest?: number;
+                atomic?: boolean;
+                maxMergeGap?: number;
+            };
+        } | {
+            kind: "modbus-tcp";
+            endpointId: string;
+            unitId: number;
+            table: "discrete-input" | "input-register";
+            addresses: number[];
+            read?: {
+                allowMultiRead?: boolean;
+                maxQuantityPerRequest?: number;
+                atomic?: boolean;
+                maxMergeGap?: number;
+            };
+        };
+        valueType: {
+            name: "str";
+            fromBytes: {
+                swap?: "bytes" | "words";
+                swapBytesInWords?: true;
+                filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+            };
+            encoding: "ascii" | "base64" | "hex" | "utf16le" | "utf8";
+            nulTerminated: boolean;
+            writeValidation: {
+                minLength: number | null;
+                maxLength: number | null;
+                allowedValues: string[] | null;
+            };
+        } | {
+            name: "num";
+            readUnavailableValue?: number;
+            composition: {
+                fromBytes: {
+                    swap?: "bytes" | "words";
+                    swapBytesInWords?: true;
+                    filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                };
+                byteLength: number;
+                packing: "bcd-int" | "decimal16" | "decimal32" | "decimal64" | "float16" | "float32" | "float64" | "signed-int" | "unsigned-int";
+            };
+            multiplier: number;
+            shift: number;
+            decimalPlaces: number | null;
+            transform: {
+                fromRead: string;
+                toWrite: string | null;
+            } | null;
+            writeValidation: {
+                min: number | null;
+                max: number | null;
+            };
+            zones: {
+                min: number | null;
+                lowOrangeBegins: number | null;
+                greenBegins: number | null;
+                highOrangeBegins: number | null;
+                highRedBegins: number | null;
+                max: number | null;
+            } | null;
+        } | {
+            name: "int";
+            readUnavailableValue?: number;
+            composition: {
+                fromBytes: {
+                    swap?: "bytes" | "words";
+                    swapBytesInWords?: true;
+                    filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                };
+                byteLength: number;
+                packing: "bcd" | "signed-int" | "unsigned-int";
+            } | {
+                fromBits: number[];
+                signed: boolean;
+            };
+            multiplier: number;
+            shift: number;
+            transform: {
+                fromRead: string;
+                toWrite: string | null;
+            } | null;
+            writeValidation: {
+                min: number | null;
+                max: number | null;
+            };
+            repr: {
+                value: number;
+                repr: string | Record<string, string>;
+                zone: "green" | "orange" | "red" | null;
+            }[] | null;
+        } | {
+            name: "bool";
+            bit: number | null;
+            repr: {
+                true: string | Record<string, string>;
+                false: string | Record<string, string>;
+            } | null;
+        } | {
+            name: "bigint";
+            byteRelation: {
+                swap?: "bytes" | "words";
+                swapBytesInWords?: true;
+                filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+            };
+            signed: boolean;
+            multiplier: string;
+            shift: string;
+            transform: {
+                fromRead: string;
+                toWrite: string | null;
+            } | null;
+            writeValidation: {
+                min: string | null;
+                max: string | null;
+                allowedValues: string[] | null;
+            };
+        } | {
+            name: "datetime";
+            composition: {
+                kind: "timestamp-sec-32";
+                zeroIsUnavailable?: boolean;
+            } | {
+                kind: "timestamp-msec-32";
+            } | {
+                kind: "timestamp-days-32";
+            } | {
+                kind: "timestamp-days-16";
+            } | {
+                kind: "iso-8601-string";
+            } | {
+                kind: "datetime";
+                year: {
+                    bytePosition: number;
+                } | {
+                    wordPosition: number;
+                } | null;
+                month: {
+                    bytePosition: number;
+                    startsFromOne: boolean;
+                } | null;
+                day: {
+                    bytePosition: number;
+                    startsFromOne: boolean;
+                } | null;
+                hour: {
+                    bytePosition: number;
+                    amPmBitPosition: number | null;
+                } | null;
+                minute: {
+                    bytePosition: number;
+                } | null;
+                second: {
+                    bytePosition: number;
+                } | null;
+                millisecond: {
+                    wordPosition: number;
+                } | null;
+                timezoneOffset: {
+                    pos: {
+                        bytePosition: number;
+                    } | {
+                        wordPosition: number;
+                    };
+                    value: "hours" | "minutes" | "seconds";
+                } | null;
+            };
+            displayFormat: string;
+            shiftSeconds: number | null;
+            timezone: string | null;
+        } | {
+            name: "ipaddr";
+            byteRelation: {
+                swap?: "bytes" | "words";
+                swapBytesInWords?: true;
+                filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+            };
+            variant: "ipv4" | "ipv6";
+        } | {
+            name: "macaddr";
+            byteRelation: {
+                swap?: "bytes" | "words";
+                swapBytesInWords?: true;
+                filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+            };
+        } | {
+            name: "geo";
+            decimalPlaces: number | null;
+            composition: {
+                encoding: "scalar";
+                longitude: {
+                    fromBytes: {
+                        swap?: "bytes" | "words";
+                        swapBytesInWords?: true;
+                        filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                    };
+                    position: number;
+                    byteLength: number;
+                    packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                    multiplier: number;
+                    shift: number;
+                };
+                latitude: {
+                    fromBytes: {
+                        swap?: "bytes" | "words";
+                        swapBytesInWords?: true;
+                        filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                    };
+                    position: number;
+                    byteLength: number;
+                    packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                    multiplier: number;
+                    shift: number;
+                };
+            } | {
+                encoding: "dms";
+                longitude: {
+                    degrees: {
+                        fromBytes: {
+                            swap?: "bytes" | "words";
+                            swapBytesInWords?: true;
+                            filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                        };
+                        position: number;
+                        byteLength: number;
+                        packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                    };
+                    minutes: {
+                        fromBytes: {
+                            swap?: "bytes" | "words";
+                            swapBytesInWords?: true;
+                            filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                        };
+                        position: number;
+                        byteLength: number;
+                        packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                    };
+                    seconds: {
+                        fromBytes: {
+                            swap?: "bytes" | "words";
+                            swapBytesInWords?: true;
+                            filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                        };
+                        position: number;
+                        byteLength: number;
+                        packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                    };
+                };
+                latitude: {
+                    degrees: {
+                        fromBytes: {
+                            swap?: "bytes" | "words";
+                            swapBytesInWords?: true;
+                            filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                        };
+                        position: number;
+                        byteLength: number;
+                        packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                    };
+                    minutes: {
+                        fromBytes: {
+                            swap?: "bytes" | "words";
+                            swapBytesInWords?: true;
+                            filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                        };
+                        position: number;
+                        byteLength: number;
+                        packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                    };
+                    seconds: {
+                        fromBytes: {
+                            swap?: "bytes" | "words";
+                            swapBytesInWords?: true;
+                            filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                        };
+                        position: number;
+                        byteLength: number;
+                        packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                    };
+                };
+                quadrant: {
+                    fromBytes: {
+                        swap?: "bytes" | "words";
+                        swapBytesInWords?: true;
+                        filterBytes?: "leave-first-byte-in-word" | "leave-last-byte-in-word";
+                    };
+                    position: number;
+                    byteLength: number;
+                    packing: "float32" | "float64" | "signed-int" | "unsigned-int";
+                };
+            };
+        };
+        disabledSince: string | null;
+        backgroundReadingPeriodMs: number | null;
+        sortOrder: number;
+        revision: number;
+        createdAt: string;
+        updatedAt: string;
+        deviceLog: {
+            pullMinutes: number;
+            lastImportAt: string | null;
+            completeThrough: string | null;
+        } | null;
+        lastReading: {
+            receivedAt: string;
+            value: string | Record<string, string>;
+            rawHex: string;
+            numberValue?: number;
+            boolValue?: boolean;
+        } | null;
+        nextReading: {
+            nextDueAt: string;
+        } | null;
+    }[] | undefined;
+};
+export interface ParameterPickerProps {
+    label: string;
+    workspaceId: string;
+    /** Whether the choice can be cleared; true by default. */
+    allowEmpty?: boolean;
+    /** Parameters this returns true for are listed first among search results. */
+    preferred?: (parameterId: string) => boolean;
+    description?: ReactNode;
+    /** When a heading next to the field already names what is picked; the label still names it. */
+    labelHidden?: boolean;
+    /** Shown after the label, such as a note that the choice is optional. */
+    labelSuffix?: ReactNode;
+    name?: string;
+    value: string;
+    onChange: (parameterId: string) => void;
+    onBlur?: () => void;
+    invalid?: boolean;
+    errors?: readonly {
+        message?: string;
+    }[];
+}
+/**
+ * Picks one of the workspace's parameters by id; an empty value means none. The field names the
+ * parameter, its branch path and its current value, read once; it opens a search over the
+ * parameter tree, as a popover or, on a phone, a sheet.
+ */
+export declare function ParameterPicker({ label, workspaceId, allowEmpty, preferred, description, labelHidden, labelSuffix, name, value, onChange, onBlur, invalid, errors, }: ParameterPickerProps): import("react").JSX.Element;

package/dist/src/workspace/parameters/runtime-errors.d.ts

@@ -0,0 +1,23 @@
+import type { ParameterRuntimeErrorParams, ParameterRuntimeErrorReason } from "@overvis/hmi-shared/parameter";
+/** One failed request a collapsed diagnostic covers. */
+export interface ParameterRuntimeErrorRequest {
+    params?: ParameterRuntimeErrorParams;
+}
+/** The exception the device answered with, such as "Modbus exception 2 (Illegal data address)". */
+export declare function modbusExceptionLabel(params: ParameterRuntimeErrorParams | undefined): string | null;
+/** What to check when the device rejected the address of a read or a write. */
+export declare function modbusAccessHelp(params: ParameterRuntimeErrorParams | undefined): string | null;
+/**
+ * Registers of failed requests, merged into ranges per table, such as
+ * "hold 100-141, 200; in 3-5". Ranges past `limit` are counted rather than listed.
+ */
+export declare function modbusRegisterRangesText(requests: readonly ParameterRuntimeErrorRequest[], limit?: number): string | null;
+/**
+ * User-facing runtime error text from `code` + optional `reason`/`params`.
+ * Prefer structured translation catalog templates. English transport/debug details are logs only.
+ */
+export declare function parameterRuntimeErrorText(input: {
+    code: string;
+    reason?: ParameterRuntimeErrorReason;
+    params?: ParameterRuntimeErrorParams;
+}): string;

package/dist/src/workspace/parameters/source-fields.d.ts

@@ -0,0 +1,22 @@
+import type { EndpointListItem } from "@overvis/hmi-shared/endpoint";
+import { type Parameter, type ParameterFormCalcSource, type ParameterFormSource } from "@overvis/hmi-shared/parameter";
+export declare function ConstSourceFields({ source, onChange, }: {
+    source: Extract<ParameterFormSource, {
+        kind: "const";
+    }>;
+    onChange: (next: ParameterFormSource) => void;
+}): import("react").JSX.Element;
+export declare function CalcSourceFields({ source, paramChoices, onChange, }: {
+    source: ParameterFormCalcSource;
+    paramChoices: Parameter[];
+    onChange: (next: ParameterFormSource) => void;
+}): import("react").JSX.Element;
+export declare function ModbusSourceFields({ source, endpoints, addressesText, onAddressesTextChange, onChange, }: {
+    source: Extract<ParameterFormSource, {
+        kind: "modbus-tcp";
+    }>;
+    endpoints: EndpointListItem[];
+    addressesText: string;
+    onAddressesTextChange: (text: string) => void;
+    onChange: (next: ParameterFormSource) => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/parameters/value/cells.d.ts

@@ -0,0 +1,21 @@
+import type { ParameterValueType } from "@overvis/hmi-shared/parameter";
+import { type ParamValueDisplayMode, type ParamValueState } from "./state.js";
+export declare function ParameterReadLiveControls({ selectedCount, live, readPending, writePending, displayMode, onRead, onLiveChange, onDisplayModeChange, }: {
+    selectedCount: number;
+    live: boolean;
+    readPending: boolean;
+    writePending: boolean;
+    displayMode: ParamValueDisplayMode;
+    onRead: () => void;
+    onLiveChange: (enabled: boolean) => void;
+    onDisplayModeChange: (mode: ParamValueDisplayMode) => void;
+}): import("react").JSX.Element;
+/** Subscribes to one param id so live polls do not re-render the whole tree. */
+export declare function useParamValueState(paramId: string): ParamValueState | undefined;
+/** Subscribes to one param id so live polls do not re-render the whole tree. */
+export declare function ParameterValueSlot({ paramId, units, writable, valueType, }: {
+    paramId: string;
+    units: string | null;
+    writable: boolean;
+    valueType: ParameterValueType;
+}): import("react").JSX.Element;

package/dist/src/workspace/parameters/value/edit-draft.d.ts

@@ -0,0 +1,24 @@
+import { type AppLocale, type LocalizedLiveValue } from "@overvis/hmi-shared";
+import { type ParameterValueType } from "@overvis/hmi-shared/parameter";
+import { type ParamValueDisplayMode } from "./state.js";
+/** Resolve displayed labels and editable wire values together, including ambiguous repr labels. */
+export declare function parameterValueEditDraft({ valueType, currentValue, rawHex, numberValue, boolValue, displayMode, locale, }: {
+    valueType: ParameterValueType;
+    currentValue?: LocalizedLiveValue | undefined;
+    rawHex?: string | undefined;
+    numberValue?: number | undefined;
+    boolValue?: boolean | undefined;
+    displayMode: ParamValueDisplayMode;
+    locale?: AppLocale;
+}): {
+    displayValue: string;
+    choices: import("../writability.js").ParameterValueEditChoice[] | null;
+    matchedChoice: import("../writability.js").ParameterValueEditChoice | null;
+    initialDraft: string;
+};
+/** Convert a datetime draft once; Setup also accepts pasted ISO timestamps. */
+export declare function parameterValueWriteDraft({ text, valueType, strictDateTime, }: {
+    text: string;
+    valueType: ParameterValueType;
+    strictDateTime?: boolean;
+}): string | null;

package/dist/src/workspace/parameters/value/reads.d.ts

@@ -0,0 +1,54 @@
+import { type ReactNode } from "react";
+import type { ParamTreeSelectionStore } from "../../setup/parameters/selection.js";
+import { type ParamValueDisplayMode, type ParamValueState } from "./state.js";
+type ParamValueListener = () => void;
+interface ParamValueStore {
+    get: (paramId: string) => ParamValueState | undefined;
+    subscribe: (paramId: string, listener: ParamValueListener) => () => void;
+    update: (fn: (prev: Map<string, ParamValueState>) => Map<string, ParamValueState>) => void;
+}
+export declare const ParamValueStoreContext: import("react").Context<ParamValueStore | null>;
+export declare function ParamValueStoreProvider({ store, children, }: {
+    store: ParamValueStore;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<ParamValueStore | null>>;
+interface ParamValueEditSession {
+    editingParamId: string | null;
+    startEdit: (paramId: string) => void;
+    cancelEdit: () => void;
+    commitWrite: (paramId: string, payload: {
+        value: string;
+    } | {
+        rawHex: string;
+    }) => void;
+    live: boolean;
+    displayMode: ParamValueDisplayMode;
+}
+export declare const ParamValueEditSessionContext: import("react").Context<ParamValueEditSession | null>;
+export declare function ParamValueEditSessionProvider({ value, children, }: {
+    value: ParamValueEditSession;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<ParamValueEditSession | null>>;
+export declare function ParamValueDisplayModeProvider({ mode, children, }: {
+    mode: ParamValueDisplayMode;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<ParamValueDisplayMode>>;
+export declare function useParamValueDisplayMode(): ParamValueDisplayMode;
+export declare function useParameterValueReads(selectionStore: ParamTreeSelectionStore, paramIdsInTreeOrder: readonly string[]): {
+    live: boolean;
+    setLiveEnabled: (enabled: boolean) => void;
+    clearParamSelectionSideEffects: (nextSelectedCount: number) => void;
+    paramValueStore: ParamValueStore;
+    readPending: boolean;
+    anySaving: boolean;
+    runRead: (parameterIds: string[]) => void;
+    editingParamId: string | null;
+    startEdit: (parameterId: string) => void;
+    cancelEdit: () => void;
+    commitWrite: (parameterId: string, payload: {
+        value: string;
+    } | {
+        rawHex: string;
+    }) => void;
+};
+export {};