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

package/dist/src/workspace/fleet/command-steps.d.ts

@@ -0,0 +1,65 @@
+import type { ParameterControl } from "@overvis/hmi-shared/parameter";
+import { type FormFieldErrors } from "../../form/index.js";
+import { type ParameterInfo } from "./parameters.js";
+type CommandStep = Extract<ParameterControl, {
+    kind: "command";
+}>["steps"][number];
+/** Form value of one command step; an empty `parameterId` is reported by `commandStepsErrors`. */
+export interface CommandStepFormValue {
+    id: string;
+    parameterId: string;
+    value: string;
+}
+/**
+ * Form value of an ordered command: steps keyed by their IDs, so field errors follow a step when
+ * it moves. Key order is the write order.
+ */
+export interface CommandStepsFormValue {
+    steps: Record<string, CommandStepFormValue>;
+}
+/** Form value of `steps`; without steps, one empty step that writes 1. */
+export declare function commandStepsFormValue(steps: readonly CommandStep[] | null | undefined): CommandStepsFormValue;
+/** Steps in write order, for a command's `steps` once `commandStepsErrors` found nothing. */
+export declare function commandStepsFromForm(value: CommandStepsFormValue): CommandStep[];
+/**
+ * Field errors of a command-steps value at `path` (the form path of the group, such as
+ * `commands.defrost`, or "" at the top level): at least one step, every step bound to a verified
+ * writable parameter, and a value for every step.
+ */
+export declare function commandStepsErrors(value: CommandStepsFormValue, path: string, parameterInfo: (parameterId: string) => Promise<ParameterInfo | "unavailable" | null>): Promise<FormFieldErrors>;
+/**
+ * Ordered write steps of a command: a writable parameter and a value per step, with Earlier and
+ * Later to change the order. Place it with `fields` at an object holding `steps`
+ * (`commandStepsFormValue`), and check it on submit with `commandStepsErrors`.
+ */
+export declare const CommandStepsField: <TFormData, TFields extends import("@tanstack/react-form").DeepKeysOfType<TFormData, CommandStepsFormValue | null | undefined> | import("@tanstack/react-form").FieldsMap<TFormData, CommandStepsFormValue>, TOnMount extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnChange extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnChangeAsync extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TOnBlur extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnBlurAsync extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TOnSubmit extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnSubmitAsync extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TOnDynamic extends undefined | import("@tanstack/react-form").FormValidateOrFn<TFormData>, TOnDynamicAsync extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TOnServer extends undefined | import("@tanstack/react-form").FormAsyncValidateOrFn<TFormData>, TFormSubmitMeta>(params: import("react").PropsWithChildren<NoInfer<{
+    workspaceId: string;
+}> & {
+    form: import("@tanstack/react-form").AppFieldExtendedReactFieldGroupApi<unknown, TFormData, string | import("@tanstack/react-form").FieldsMap<unknown, TFormData>, any, any, any, any, any, any, any, any, any, any, TFormSubmitMeta, {
+        readonly TextField: typeof import("../../index.js").TextField;
+        readonly TextAreaField: typeof import("../../index.js").TextAreaField;
+        readonly OtpField: typeof import("../../index.js").OtpField;
+        readonly CheckboxField: typeof import("../../index.js").CheckboxField;
+        readonly ParameterPickerField: typeof import("../../index.js").ParameterPickerField;
+        readonly DashboardPickerField: typeof import("../../index.js").DashboardPickerField;
+        readonly FormulaField: typeof import("../../index.js").FormulaField;
+    }, {
+        readonly FormRoot: typeof import("../../index.js").FormRoot;
+        readonly FormErrorBanner: typeof import("../../index.js").FormErrorBanner;
+        readonly SubmitButton: typeof import("../../index.js").SubmitButton;
+    }> | import("@tanstack/react-form").AppFieldExtendedReactFormApi<TFormData, TOnMount, TOnChange, TOnChangeAsync, TOnBlur, TOnBlurAsync, TOnSubmit, TOnSubmitAsync, TOnDynamic, TOnDynamicAsync, TOnServer, TFormSubmitMeta, {
+        readonly TextField: typeof import("../../index.js").TextField;
+        readonly TextAreaField: typeof import("../../index.js").TextAreaField;
+        readonly OtpField: typeof import("../../index.js").OtpField;
+        readonly CheckboxField: typeof import("../../index.js").CheckboxField;
+        readonly ParameterPickerField: typeof import("../../index.js").ParameterPickerField;
+        readonly DashboardPickerField: typeof import("../../index.js").DashboardPickerField;
+        readonly FormulaField: typeof import("../../index.js").FormulaField;
+    }, {
+        readonly FormRoot: typeof import("../../index.js").FormRoot;
+        readonly FormErrorBanner: typeof import("../../index.js").FormErrorBanner;
+        readonly SubmitButton: typeof import("../../index.js").SubmitButton;
+    }>;
+    fields: TFields;
+}>) => ReturnType<import("react").FunctionComponent>;
+export {};

package/dist/src/workspace/fleet/control-mode.d.ts

@@ -0,0 +1,30 @@
+import type { ParameterCondition } from "@overvis/hmi-shared/parameter";
+import type { ParameterValueState } from "../parameters/live/model.js";
+import type { SiteState } from "./status.js";
+type States = ReadonlyMap<string, ParameterValueState>;
+/** Who controls a site: its own controller, an operator, a local selector, or nobody knows. */
+export declare const siteControlModes: readonly ["automatic", "manual", "local", "unknown"];
+export type SiteControlMode = (typeof siteControlModes)[number];
+/** A site's local/remote selector; `unbound` when the site does not report one. */
+export type SiteLocalControl = "on" | "off" | "unknown" | "unbound";
+/**
+ * The control mode from the site's feedback: Local while the local selector is on, otherwise
+ * Automatic or Manual from the automatic-mode condition, Unknown while that feedback is
+ * unavailable. Null when the site reports neither. The mode never changes the site status.
+ */
+export declare function siteControlMode(feedback: {
+    automatic?: ParameterCondition | undefined;
+    local?: ParameterCondition | undefined;
+}, states: States): SiteControlMode | null;
+/**
+ * The local selector: `on` blocks remote commands, `unknown` leaves them enabled with a note, and
+ * `off` or `unbound` allows them.
+ */
+export declare function siteLocalControl(local: ParameterCondition | undefined, states: States): SiteLocalControl;
+/**
+ * Whether a site's equipment runs, from its activity feedback: `active` while any of it is on,
+ * `inactive` while all of it is off, `unknown` while some feedback is missing. Null while the
+ * site has no current activity feedback, so callers show its status instead.
+ */
+export declare function siteActivity(state: SiteState): "active" | "inactive" | "unknown" | null;
+export {};

package/dist/src/workspace/fleet/counter-bars.d.ts

@@ -0,0 +1,109 @@
+import { type CounterPeriod } from "@overvis/hmi-shared/dashboard";
+/**
+ * Buckets that fit a counter period: hours up to two days (with an hour to spare for a DST
+ * change), days for longer periods.
+ */
+export declare function counterBucketCadence(period: Pick<CounterPeriod, "window">): "1h" | "1d";
+/**
+ * The reading of a parameter with the largest magnitude in a window `[from, to)`, with its sign
+ * and time, such as the peak power of the period: negative when export peaked, as for a supply
+ * that only fed back. Null until known or when the window has no readings.
+ */
+export declare function useReadingPeak(workspaceId: string, parameterId: string | null, window: CounterPeriod["window"]): {
+    value: number;
+    time: number;
+} | null;
+/** One bar's window: its bucket, clipped to the period. */
+export interface CounterBucket {
+    /** Bucket start in the time zone, the bar's label. */
+    start: number;
+    from: number;
+    to: number;
+    /**
+     * Covers part of its bucket: the one still in progress, or a rolling period's first bucket,
+     * which began before the period. Drawn lighter and left out of the average.
+     */
+    partial: boolean;
+}
+/**
+ * The buckets of a period, each clipped to `[from, to)`, so their increases add up to the period's
+ * total. Hours and calendar days follow `timeZone`, so a DST day lasts 23 or 25 hours.
+ */
+export declare function counterBuckets(window: CounterPeriod["window"], cadence: "1h" | "1d", timeZone: string): CounterBucket[];
+declare const BUCKET_AGGREGATIONS: readonly ["first", "latest", "min"];
+type AggregateValues = readonly {
+    aggregation: string;
+    value: unknown;
+}[];
+/**
+ * Each bucket's increase, chained from one reading to the next: a bucket runs from the latest
+ * reading before it (`baseline` for the first bucket, as for the period total) to its own latest,
+ * so the bars add up to the period total however short a clipped edge bucket is. Each is
+ * classified like a period total: a value (an idle bucket is 0), or null for a reset, which also
+ * catches a drop between buckets, or a bucket without readings. Without a baseline the first
+ * reading starts the chain, as it starts a period total without one.
+ */
+export declare function counterBucketValues(baseline: number | null, buckets: readonly (Pick<CounterBucket, "from" | "to"> & {
+    values: AggregateValues | undefined;
+})[]): (number | null)[];
+/** A window read with `readings.aggregate`, inside one bucket. */
+export interface CounterBucketEdge {
+    bucket: number;
+    from: number;
+    to: number;
+}
+/** How a chart loads its buckets' first, latest and min readings. */
+export interface CounterBucketsLoad {
+    /**
+     * Closed rollup rows over `[from, to)`: local days from `readings.days`, or UTC quarter hours
+     * from `readings.cadence`, each falling inside one bucket. Null when the edges cover everything.
+     */
+    grains: {
+        source: "days" | "15m";
+        from: number;
+        to: number;
+    } | null;
+    /** The rest of the period, split at bucket bounds. */
+    edges: CounterBucketEdge[];
+}
+/**
+ * Splits loading the buckets of a period into one rollup read per aggregation and a few edge
+ * windows. Rollup rows start at the first bucket that starts inside the period: a rolling period's
+ * first bucket is an edge, so the rollup window stays put while the period rolls. They end one
+ * grain before the last closed one, which may not be rolled up yet; readings from there on are
+ * edges. Rows must not straddle a bucket bound: where a zone offsets its hours or days from UTC
+ * grains (such as UTC+05:45 for days), every bucket is an edge.
+ */
+export declare function counterBucketsLoad(buckets: readonly CounterBucket[], cadence: "1h" | "1d"): CounterBucketsLoad;
+/** `readings.days` or `readings.cadence` rows of one aggregation for one parameter. */
+type GrainRows = readonly {
+    bucketStart: number;
+    values: readonly {
+        value: unknown;
+    }[];
+}[];
+/**
+ * Each bucket's first, latest and min from its parts in time order: rollup rows of the three
+ * aggregations, placed by their start, and the edge aggregates. Undefined for a bucket without
+ * readings.
+ */
+export declare function counterBucketReadings(buckets: readonly Pick<CounterBucket, "start">[], edges: readonly (CounterBucketEdge & {
+    values: AggregateValues | undefined;
+})[], grains: Readonly<Record<(typeof BUCKET_AGGREGATIONS)[number], GrainRows>> | null): (AggregateValues | undefined)[];
+/**
+ * A counter's increase per bucket of the period as a compact bar chart: per hour up to two days,
+ * per calendar day in `timeZone` beyond. Bars carry their values when they fit, the axis their
+ * dates, and a dashed line the average of the closed buckets; the bucket still in progress is
+ * lighter. A decrease, such as a counter reset, draws no bar. Renders nothing when the period has
+ * no increase.
+ */
+export declare function CounterBars({ workspaceId, parameterId, period, timeZone, unit, ariaLabel, className, }: {
+    workspaceId: string;
+    parameterId: string;
+    period: Pick<CounterPeriod, "window">;
+    timeZone: string;
+    unit: string;
+    ariaLabel: string;
+    className?: string | undefined;
+}): import("react").JSX.Element | null;
+export {};

package/dist/src/workspace/fleet/counter-notices.d.ts

@@ -0,0 +1,23 @@
+import type { CounterTotals } from "./counter-totals.js";
+/**
+ * Why period totals stay empty after their requests failed, with a retry. Without it the totals
+ * would keep their loading skeletons: failed requests are not retried by themselves, and a
+ * completed period's requests never change.
+ */
+export declare function CounterTotalsNotice({ totals, }: {
+    totals: Pick<CounterTotals, "isError" | "retry">;
+}): import("react").JSX.Element | null;
+/**
+ * Setup warnings for counter bindings that don't block saving: a counter without background
+ * readings records history only while someone views it, and a counter whose unit differs from its
+ * parent's has no share of it.
+ */
+export declare function CounterBindingWarnings({ counters, share, }: {
+    /** Bound counter parameter IDs; one bound in several roles is warned about once. */
+    counters: readonly string[];
+    /** A counter shown as a share of its parent's, whose units must match. */
+    share?: {
+        counter: string;
+        parent: string;
+    };
+}): import("react").JSX.Element | null;

package/dist/src/workspace/fleet/counter-period.d.ts

@@ -0,0 +1,35 @@
+import { type CounterPeriod, type CounterPeriodId } from "@overvis/hmi-shared/dashboard";
+/** Name of a counter period in the UI language, such as "Last 7 days". */
+export declare function counterPeriodLabel(id: CounterPeriodId): string;
+/**
+ * Comparison caption of a resolved counter period in the UI language, such as "vs same time
+ * yesterday". A month in progress compared with the whole shorter previous month reads "vs the
+ * month before".
+ */
+export declare function counterComparisonLabel(period: CounterPeriod): string;
+export interface UseCounterPeriodOptions {
+    /** URL search key holding the period. Default: `"period"`. */
+    searchKey?: string;
+    /** Periods offered, in order. Default: every period. */
+    periods?: readonly CounterPeriodId[];
+    /** Period when the URL has none or an unknown one; must be in `periods`. Default: the first. */
+    defaultPeriod?: CounterPeriodId;
+}
+/** The counter period in the dashboard URL and a setter that replaces it there. */
+export declare function useCounterPeriod({ searchKey, periods, defaultPeriod, }?: UseCounterPeriodOptions): {
+    period: CounterPeriodId;
+    periods: readonly CounterPeriodId[];
+    setPeriod: (period: CounterPeriodId) => void;
+};
+/**
+ * A dashboard's time zone setting (`dashboardTimeZoneType`) as a zone: the viewer's own for
+ * `browser`, the workspace's when the setting is absent.
+ */
+export declare function useDashboardTimeZone(setting: string | undefined): string;
+/**
+ * The counter period in the URL, resolved like the counter totals: rolling periods end at the last
+ * closed minute, calendar periods follow `timeZone`. Refreshes at each closed minute.
+ */
+export declare function useResolvedCounterPeriod({ timeZone, ...options }: UseCounterPeriodOptions & {
+    timeZone: string;
+}): CounterPeriod;

package/dist/src/workspace/fleet/counter-shares.d.ts

@@ -0,0 +1,34 @@
+import type { CounterPeriodId } from "@overvis/hmi-shared/dashboard";
+import type { CounterPeriodTotal, CounterTotals } from "./counter-totals.js";
+/** A counter bound in a dashboard configuration, with the unit saved beside it. */
+export interface CounterSlot {
+    parameterId: string;
+    unit: string;
+}
+/** The value of a period total for sorting and bars; null without one. Never 0 for missing data. */
+export declare function counterTotalValue(total: CounterPeriodTotal | undefined): number | null;
+/** A counter's unit: the parameter's when it has one, otherwise the unit saved with the slot. */
+export declare function counterSlotUnit(totals: Pick<CounterTotals, "unit">, slot: CounterSlot): string;
+/**
+ * A part's share of its whole over the period: only when both are whole-period values in the same
+ * unit and the whole is positive. Shares are display ratios and need not add up to 1.
+ */
+export declare function counterShare(part: CounterPeriodTotal | undefined, whole: CounterPeriodTotal | undefined, partUnit: string, wholeUnit: string): number | null;
+/** A share as a percentage with at most one decimal, such as "42.5%". */
+export declare function formatCounterShare(share: number, locale: string): string;
+/**
+ * The unit most counters use (the first on a tie), or null without units. Totals in other units
+ * can't be ranked or stacked against them, since units are never converted.
+ */
+export declare function commonCounterUnit(units: readonly string[]): string | null;
+export interface RankedCounter<Item> {
+    item: Item;
+    value: number;
+    unit: string;
+}
+/**
+ * The items whose counters have the most in the period, largest first, at most `count`, in the
+ * unit most of the counters use. Partial totals cover less time, so only whole-period positive
+ * values are ranked.
+ */
+export declare function rankByCounterTotal<Item>(items: readonly Item[], counterOf: (item: Item) => CounterSlot | null | undefined, totals: Pick<CounterTotals, "find" | "unit">, periodId: CounterPeriodId, count: number): RankedCounter<Item>[];

package/dist/src/workspace/fleet/counter-total.d.ts

@@ -0,0 +1,43 @@
+import { type UseCounterPeriodOptions } from "./counter-period.js";
+import type { CounterPeriodTotal } from "./counter-totals.js";
+/** A period select bound to a URL search key; read the same key with `useCounterPeriod`. */
+export declare function CounterPeriodSelect({ className, label, ...options }: UseCounterPeriodOptions & {
+    className?: string;
+    /** Accessible name. Default: "Period". */
+    label?: string;
+}): import("react").JSX.Element;
+/**
+ * A counter total for display, with thousands grouped and fewer decimals as it grows: two below
+ * 100, one below 10 000, none above. `maximumFractionDigits` overrides the choice.
+ */
+export declare function formatCounterValue(value: number, unit: string, locale: string, maximumFractionDigits?: number): string;
+/**
+ * A counter's consumption in one period: value with unit and a change badge, "No data" without
+ * readings, "Counter reset" without a value, and "Since …" / "Until …" for partial coverage.
+ * `compact` fits a table cell or list row: a smaller value without the change, which
+ * `CounterChange` shows on its own. `change={false}` leaves the change out at full size too, and
+ * `valueClassName` restyles the value, such as a larger headline figure.
+ */
+export declare function CounterTotal({ total, unit, maximumFractionDigits, compact, change, valueClassName, className, }: {
+    /** From `useCounterTotals().find`; undefined while it loads. */
+    total: CounterPeriodTotal | undefined;
+    unit: string;
+    /** Default: by magnitude, see `formatCounterValue`. */
+    maximumFractionDigits?: number | undefined;
+    compact?: boolean;
+    change?: boolean;
+    valueClassName?: string | undefined;
+    className?: string | undefined;
+}): import("react").JSX.Element;
+/**
+ * The change of a counter total against its comparison window as a badge, such as "+12 %";
+ * nothing unless both windows have values. `comparison` adds the caption ("vs previous 7 days").
+ * `rising` tints the badge by which direction is welcome: green for more export with `"good"`,
+ * amber for more consumption or cost with `"bad"`; without it the badge stays neutral.
+ */
+export declare function CounterChange({ total, comparison, rising, className, }: {
+    total: CounterPeriodTotal | undefined;
+    comparison?: boolean;
+    rising?: "good" | "bad";
+    className?: string;
+}): import("react").JSX.Element | null;

package/dist/src/workspace/fleet/counter-totals.d.ts

@@ -0,0 +1,77 @@
+import { type CounterPeriod, type CounterPeriodId, type CounterTotalResult } from "@overvis/hmi-shared/dashboard";
+import type { ReportReadingsClient } from "../reports/readings-client.js";
+/** A `num` counter and how its history is recorded. */
+export interface CounterSource {
+    parameterId: string;
+    /** Null when background readings are off. */
+    backgroundReadingPeriodMs: number | null;
+    /**
+     * For a counter with device-logged history, the time through which its device's log is
+     * imported; null otherwise.
+     */
+    deviceLogCompleteThrough: number | null;
+}
+interface CounterExtent {
+    from: number | null;
+    to: number | null;
+    /** When the extent was requested; readings after it may be missing from `to`. */
+    fetchedAt: number;
+}
+/** Page cache of a counter-totals hook: extents per counter and values of repeated windows. */
+export interface CounterTotalsCache {
+    extents: Map<string, CounterExtent>;
+    values: Map<string, number | null>;
+    /** The import watermark each device-logged counter's cached extent and values belong to. */
+    watermarks: Map<string, number>;
+}
+export declare function createCounterTotalsCache(): CounterTotalsCache;
+export interface CounterPeriodTotal {
+    parameterId: string;
+    period: CounterPeriod;
+    current: CounterTotalResult;
+    previous: CounterTotalResult;
+    /** Relative change against `previous`, e.g. `0.25` for +25 %; null unless both are values. */
+    change: number | null;
+}
+/**
+ * Loads consumption totals for counters over resolved periods. `readings.aggregate` gives
+ * `delta`, `first`, `latest` and `min` per window in requests of at most 100 pairs.
+ * `readings.timeExtent` runs once per counter and is kept in `cache`; when a window end lies
+ * past the cached extent, a `latest` over its last background period plus a minute shows
+ * whether readings reach it. Only a counter whose readings stopped, or one cached without readings
+ * that has some now, asks for its extent again.
+ */
+export declare function loadCounterTotals(options: {
+    workspaceId: string;
+    readings: Pick<ReportReadingsClient, "aggregate" | "timeExtent">;
+    counters: readonly CounterSource[];
+    periods: readonly CounterPeriod[];
+    cache: CounterTotalsCache;
+    now?: () => number;
+    signal: AbortSignal;
+}): Promise<CounterPeriodTotal[]>;
+export interface UseCounterTotalsOptions {
+    workspaceId: string;
+    /** Counter parameter ids; only `num` parameters give totals (see `counterBindingError`). */
+    counters: readonly string[];
+    periods: readonly CounterPeriodId[];
+    /** IANA timezone for calendar periods; the browser's by default. */
+    timeZone?: string;
+}
+export interface CounterTotals {
+    totals: readonly CounterPeriodTotal[];
+    /** Total of one counter in one period; undefined while it loads or after its lookup failed. */
+    find: (parameterId: string, period: CounterPeriodId) => CounterPeriodTotal | undefined;
+    /** Unit of a counter from its parameter, in the UI language; empty when it has none. */
+    unit: (parameterId: string) => string;
+    isPending: boolean;
+    isError: boolean;
+    retry: () => void;
+}
+/**
+ * Consumption of counters (energy, heat, water, gas) per period with a comparison, refreshed at
+ * each closed minute. Missing history is `no-data`, never 0; a counter reset is flagged without a
+ * value; partial coverage carries its range and no change.
+ */
+export declare function useCounterTotals({ workspaceId, counters, periods, timeZone, }: UseCounterTotalsOptions): CounterTotals;
+export {};

package/dist/src/workspace/fleet/due-dates.d.ts

@@ -0,0 +1,18 @@
+import { type ParameterValueState } from "../parameters/live/model.js";
+/** A piece of equipment with an optional due-date parameter, such as maintenance or verification. */
+export interface SiteDueEquipment {
+    id: string;
+    name: string;
+    maintenanceParameterId?: string | undefined;
+}
+/** The due-date parameters of `equipment`, to add to a page's live demand. */
+export declare function dueDateParameterIds(equipment: readonly SiteDueEquipment[]): string[];
+/**
+ * The equipment whose due date has passed at `now`, by name and id. Dates must be current values;
+ * `unknown` is true when any bound date is not, so none of those is known to be overdue.
+ */
+export declare function overdueEquipment(equipment: readonly SiteDueEquipment[], states: ReadonlyMap<string, ParameterValueState>, now: number): {
+    overdue: string[];
+    overdueIds: string[];
+    unknown: boolean;
+};

package/dist/src/workspace/fleet/duplicate-dialog.d.ts

@@ -0,0 +1,63 @@
+import { type FleetZone } from "@overvis/hmi-shared/dashboard";
+import { type FormValidationErrorResult } from "../../form/index.js";
+/** One copy the dialog creates: its name, zone, target branch and parameter mapping. */
+export interface SiteDuplicateCopy {
+    name: string;
+    zoneId: string | null;
+    branch: readonly string[];
+    mapping: ReadonlyMap<string, string | null>;
+}
+/**
+ * Names of copies to several branches: each branch's last segment, or the whole path when two
+ * chosen branches end the same way.
+ */
+export declare function duplicateCopyNames(branches: readonly (readonly string[])[]): string[];
+/**
+ * Copies a site for identical equipment elsewhere in the parameter tree: every binding is
+ * matched to the parameter with the same relative path under the chosen branch. `plan` names
+ * the bindings a mapping would leave out. With `onSave` the user picks one branch and names the
+ * copy; with `onSaveAll` the user picks one or more branches and gets one copy per branch, named
+ * after it (no name field), saved in one call. Without `zones` there is no zone field.
+ */
+export declare function SiteDuplicateDialog({ siteName, zoneId, zones, parameterIds, workspaceId, plan, onSave, onSaveAll, onClose, onDuplicated, labels, mapError, }: {
+    siteName: string;
+    zoneId?: string | null;
+    /** Zones offered for the copy; omit when the preset has no zones. */
+    zones?: readonly FleetZone[];
+    /** Every parameter the site binds, including command steps. */
+    parameterIds: readonly string[];
+    workspaceId: string;
+    plan: (mapping: ReadonlyMap<string, string | null>) => readonly string[];
+    onClose: () => void;
+    onDuplicated: () => void;
+    labels?: {
+        title?: string;
+        hint?: string;
+        noBindings?: string;
+        targetRequired?: string;
+    };
+    mapError?: (error: unknown) => FormValidationErrorResult;
+} & ({
+    onSave: (copy: {
+        name: string;
+        zoneId: string | null;
+        mapping: ReadonlyMap<string, string | null>;
+    }) => Promise<void>;
+    onSaveAll?: never;
+} | {
+    /** Creates every copy in one configuration update. */
+    onSaveAll: (copies: readonly SiteDuplicateCopy[]) => Promise<void>;
+    onSave?: never;
+})): import("react").JSX.Element;
+/**
+ * What the chosen copies will leave out, per branch; for copies named after their branches, the
+ * names and a count
+ * of branches where everything matches.
+ */
+export declare function CopyPlan({ copies, }: {
+    copies: readonly {
+        branch: readonly string[];
+        name: string | null;
+        dropped: readonly string[];
+    }[];
+}): import("react").JSX.Element | null;

package/dist/src/workspace/fleet/editor-dialog.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from "react";
+/** Setup dialog with a fixed header, a scrolling body and a footer that stays in view. */
+export declare function FleetEditorDialog({ title, children, onClose, description, }: {
+    title: string;
+    children: ReactNode;
+    onClose: () => void;
+    description?: string;
+}): import("react").JSX.Element;
+/**
+ * Body and footer of a `FleetEditorDialog` form; use inside `form.FormRoot layout="dialog-fill"`.
+ * Form errors appear above the footer actions. Omit children for a confirmation.
+ */
+export declare function FleetEditorForm({ footer, children, }: {
+    footer: ReactNode;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+/** A labeled select over fixed options. */
+export declare function FleetChoice<Value extends string>({ label, value, options, onChange, }: {
+    label: string;
+    value: Value;
+    options: readonly {
+        value: Value;
+        label: string;
+    }[];
+    onChange: (value: Value) => void;
+}): import("react").JSX.Element;

package/dist/src/workspace/fleet/equipment-setup.d.ts

@@ -0,0 +1,44 @@
+import type { ReactElement } from "react";
+import type { SiteAlarm, SiteEquipment, SiteEquipmentListKind } from "@overvis/hmi-shared/dashboard";
+import type { ParameterValueState } from "../parameters/live/model.js";
+type EquipmentLists = Pick<SiteEquipment, SiteEquipmentListKind>;
+type EquipmentItem<Equipment extends EquipmentLists> = Equipment["readings"][number] | Equipment["alarms"][number] | Equipment["controls"][number];
+/** What a site's setup does with the readings, alarms and controls of one piece of equipment. */
+export interface SiteEquipmentActions<Equipment extends EquipmentLists = EquipmentLists> {
+    /** Edits an item, or adds one with `null`. */
+    onEdit: (kind: SiteEquipmentListKind, item: EquipmentItem<Equipment> | null) => void;
+    onRemove: (kind: SiteEquipmentListKind, item: EquipmentItem<Equipment>) => void;
+    onReorder: (kind: SiteEquipmentListKind) => void;
+}
+/** Edit and Remove for one reading, alarm or control in setup. */
+export declare function SiteItemActions({ onEdit, onRemove, }: {
+    onEdit: () => void;
+    onRemove: () => void;
+}): ReactElement;
+/**
+ * Active alarms of one piece of equipment as compact badges, such as in a panel's header:
+ * destructive for critical, amber for warnings. Inactive and unknown alarms are left out.
+ */
+export declare function SiteActiveAlarmBadges({ alarms, states, }: {
+    alarms: readonly SiteAlarm[];
+    states: ReadonlyMap<string, ParameterValueState>;
+}): ReactElement;
+/**
+ * The alarms of one piece of equipment: the active ones and those whose state is unknown, with
+ * their severity. In setup (`canEdit`) every alarm is listed with Edit and Remove.
+ */
+export declare function SiteAlarmList<Alarm extends SiteAlarm>({ alarms, states, canEdit, onEdit, onRemove, }: {
+    alarms: readonly Alarm[];
+    states: ReadonlyMap<string, ParameterValueState>;
+    canEdit: boolean;
+    onEdit: (alarm: Alarm) => void;
+    onRemove: (alarm: Alarm) => void;
+}): ReactElement | null;
+/**
+ * Setup of one piece of equipment: its controls with Edit and Remove, reordering of each list
+ * with two or more items, and adding a reading, alarm or control.
+ */
+export declare function SiteEquipmentSetup<Equipment extends EquipmentLists>({ equipment, onEdit, onRemove, onReorder, }: {
+    equipment: Equipment;
+} & SiteEquipmentActions<Equipment>): ReactElement;
+export {};

package/dist/src/workspace/fleet/equipment-view.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentProps, ReactNode } from "react";
+import type { AppLocale } from "@overvis/hmi-shared";
+import type { SiteEquipment } from "@overvis/hmi-shared/dashboard";
+import type { ParameterControl } from "@overvis/hmi-shared/parameter";
+import type { ParameterValueState } from "../parameters/live/model.js";
+import { type SiteEquipmentActions } from "./equipment-setup.js";
+import { EquipmentOperations } from "./operations.js";
+import type { SiteDueDate } from "./status.js";
+/**
+ * Readings, alarms and operations of a site or one piece of equipment. The `site` variant spreads
+ * the readings across the page; `equipment` is a compact block for panels. While `canEdit`, every
+ * reading and alarm has Edit and Remove, and the equipment's setup follows the operations.
+ * `aside`, such as the site's pump list, sits beside the alarms and operations on wide screens.
+ */
+export declare function SiteEquipmentView<Equipment extends SiteEquipment>({ equipment, variant, states, locale, canEdit, icon, history, dueDate, aside, commands, operationControls, onEdit, onRemove, onReorder, }: {
+    equipment: Equipment;
+    variant: "site" | "equipment";
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+    canEdit: boolean;
+    icon?: (reading: Equipment["readings"][number]) => ReactNode;
+    /** The History action of the operations; null hides it. */
+    history: ComponentProps<typeof EquipmentOperations>["history"];
+    /** Labels the due date as maintenance (default) or verification. */
+    dueDate?: SiteDueDate;
+    aside?: ReactNode;
+    /** Shown between the alarms and the operations, such as guarded command buttons. */
+    commands?: ReactNode;
+    /** The controls the operations offer; all of the equipment's by default. */
+    operationControls?: readonly ParameterControl[];
+} & SiteEquipmentActions<Equipment>): import("react").JSX.Element;

package/dist/src/workspace/fleet/figure.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from "react";
+declare const sizes: {
+    readonly large: "text-3xl/tight font-semibold";
+    readonly medium: "text-lg/tight font-semibold";
+    readonly small: "text-sm font-medium";
+};
+/**
+ * A labelled value in a `dl`, for strips of site figures in a grid such as
+ * `grid-cols-[repeat(auto-fill,minmax(7rem,1fr))]`: large for a headline reading, small for an
+ * equipment row. `wide` spans two columns, for a list such as alarms.
+ */
+export declare function SiteFigure({ label, children, size, wide, }: {
+    label: string;
+    children: ReactNode;
+    size?: keyof typeof sizes;
+    wide?: boolean;
+}): import("react").JSX.Element;
+export {};

package/dist/src/workspace/fleet/form-types.d.ts

@@ -0,0 +1,15 @@
+import Type from "typebox";
+import type { SiteRoleFormValue } from "@overvis/hmi-shared/dashboard";
+/** A parameter binding in a form: a parameter ID, or empty while unbound. */
+export declare const optionalParameterIdType: Type.TUnion<[Type.TLiteral<"">, Type.TString]>;
+/** The name of a site or a piece of equipment: 1–120 characters, not only spaces. */
+export declare const siteNameType: Type.TString;
+/** Slot rows of `SiteSlotFields`; condition values are checked when the form is saved. */
+export declare const siteSlotRowsType: Type.TRecord<"^.*$", Type.TObject<{
+    parameterId: Type.TUnion<[Type.TLiteral<"">, Type.TString]>;
+    unit: Type.TString;
+    operator: Type.TUnion<[Type.TLiteral<"eq">, Type.TLiteral<"ne">, Type.TLiteral<"gt">, Type.TLiteral<"gte">, Type.TLiteral<"lt">, Type.TLiteral<"lte">]>;
+    value: Type.TString;
+}>>;
+/** Form rows of `keys`, as `SiteSlotFields` edits them; `row` is usually the roles' `formValue`. */
+export declare function siteSlotRows<Key extends string>(keys: readonly Key[], row: (key: Key) => SiteRoleFormValue): Record<string, SiteRoleFormValue>;