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

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

@@ -0,0 +1,13 @@
+import { type SitePosition } from "@overvis/hmi-shared/dashboard";
+import { type ParameterValueState } from "../parameters/live/model.js";
+/** The geo parameter a position reads, for the overview's live demand. */
+export declare function sitePositionParameterIds(position: SitePosition | undefined): string[];
+/**
+ * Coordinates of a site: fixed ones, or the last value of its geo parameter. A stale geo value
+ * keeps the site on the map with `stale` set; a missing or invalid one leaves it off.
+ */
+export declare function resolveSitePosition(position: SitePosition | undefined, states: ReadonlyMap<string, ParameterValueState>): {
+    lat: number;
+    lng: number;
+    stale: boolean;
+} | null;

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

@@ -0,0 +1,64 @@
+import type { AppLocale } from "@overvis/hmi-shared";
+import type { SiteReading } from "@overvis/hmi-shared/dashboard";
+import { type ReactNode } from "react";
+import type { ParameterValueState } from "../parameters/live/model.js";
+/** A clock after a value that is no longer current; the value itself names the time. */
+export declare function StaleMarker({ state }: {
+    state: ParameterValueState;
+}): import("react").JSX.Element | null;
+/**
+ * A reading's live value with its unit, or a dash when the reading is not bound. Loading,
+ * unavailable and stale values stay distinct: a stale value remains visible, muted and marked
+ * with a clock.
+ */
+export declare function SiteReadingValue({ reading, states, locale, }: {
+    reading: Pick<SiteReading, "parameterId" | "unit"> | null | undefined;
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+}): import("react").JSX.Element;
+type PhaseBinding = Pick<SiteReading, "parameterId" | "unit">;
+/**
+ * Phase values on one line, L1 first ("231.2 · 234.0 · 231.3 V"): one unit after the values when
+ * the bound phases share it, otherwise each value with its own. An unbound phase shows "—".
+ * Screen readers hear the phase names.
+ */
+export declare function PhaseValues({ phases, states, locale, }: {
+    phases: readonly (PhaseBinding | null | undefined)[];
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+}): import("react").JSX.Element;
+/**
+ * One overview column of a site, for `FleetOverview` `columns`: its phases on one line when any
+ * is bound, then its readings (named when the cell shows more than one value), or "—".
+ */
+export declare function SiteReadingCell({ phases, readings, states, locale, }: {
+    phases?: readonly (PhaseBinding | null | undefined)[];
+    readings: readonly SiteReading[];
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+}): import("react").JSX.Element;
+/**
+ * A reading's name above its live value, with an optional icon. `compact` suits panels and
+ * cards; stale values are marked as in `SiteReadingValue`.
+ */
+export declare function SiteReadingMetric({ reading, states, locale, icon, compact, }: {
+    reading: Pick<SiteReading, "name" | "parameterId" | "unit">;
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+    icon?: ReactNode;
+    compact?: boolean;
+}): import("react").JSX.Element;
+/**
+ * Labeled live readings of a site or one piece of equipment. `strip` spreads large values across
+ * the page; `grid` is a compact two-column block for panels. `actions` renders setup buttons
+ * under a reading.
+ */
+export declare function SiteReadings<Reading extends SiteReading>({ readings, states, locale, layout, icon, actions, }: {
+    readings: readonly Reading[];
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+    layout?: "strip" | "grid";
+    icon?: (reading: Reading) => ReactNode;
+    actions?: (reading: Reading) => ReactNode;
+}): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,7 @@
+import type { ReactNode } from "react";
+/** A plain site page section: a small heading with optional actions, then its content. */
+export declare function SiteSection({ title, action, children, }: {
+    title: ReactNode;
+    action?: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/src/workspace/fleet/site-page.d.ts

@@ -0,0 +1,150 @@
+import { type ReactNode } from "react";
+import { type DashboardLocation, type SiteStatus } from "@overvis/hmi-shared/dashboard";
+import type { DashboardNavigation } from "../dashboards/navigation.js";
+import { type SiteActiveAlarm, type SiteMaintenanceSummary, type SiteSummaryState } from "../page-state/dashboard.js";
+import type { ParameterValueState } from "../parameters/live/model.js";
+import { type SiteStatusLabels } from "./status-badge.js";
+/**
+ * Where to open a site the overview has just created: its page in setup mode, keeping the
+ * overview's query so the page's back link returns to the same selection.
+ */
+export declare function newSiteLocation(path: string, overviewSearch: string): DashboardLocation;
+/**
+ * Setup mode of a site page at `search`, for `SitePageHeader`. A page opened from
+ * `newSiteLocation` starts in it; `editing` stays off without `canEdit`. `overviewSearch` is the
+ * page's query for links back to the overview, without the setup flag and the `pageParams` that
+ * only the site page uses.
+ */
+export declare function useSiteSetup({ search, canEdit, pageParams, }: {
+    search: string;
+    canEdit: boolean;
+    pageParams?: readonly string[];
+}): {
+    editing: boolean;
+    setEditing: (editing: boolean) => void;
+    overviewSearch: string;
+};
+/**
+ * The setup dialog open on a site page. `baseline` is the site the dialog opened with, its
+ * conflict baseline, so a concurrent change is detected on save; the current site while none is
+ * open.
+ */
+export declare function useSiteEditor<Editor, Site>(site: Site): {
+    editor: Editor | null;
+    baseline: Site;
+    open: (editor: Editor) => void;
+    close: () => void;
+};
+/** A site as the assistant's page summary describes it. */
+export interface SiteSummaryEvaluation {
+    state: SiteSummaryState;
+    alarms: readonly SiteActiveAlarm[];
+    maintenance: SiteMaintenanceSummary;
+}
+/** What a site page's summary for the assistant is built from. */
+interface SiteSummarySource<Site> {
+    site: Site;
+    sites: readonly Site[];
+    /** The page's `useReadParameterValuesOnce`. */
+    readOnce: (parameterIds: readonly string[]) => Promise<ReadonlyMap<string, ParameterValueState>>;
+    /** The parameters `evaluate` reads for one site, such as `siteAttentionParameterIds`. */
+    parameterIds: (site: Site) => readonly string[];
+    evaluate: (site: Site, states: ReadonlyMap<string, ParameterValueState>, now: number) => SiteSummaryEvaluation;
+}
+/**
+ * A site page's summary for the assistant: the site, and every site of the fleet for questions
+ * about the others. All sites are read once, so the site and the fleet cannot contradict each
+ * other.
+ */
+export declare function readSiteSummary<Site extends {
+    id: string;
+    name: string;
+}>({ site, sites, readOnce, parameterIds, evaluate, statusLabel, }: SiteSummarySource<Site> & {
+    statusLabel: (status: SiteStatus) => string;
+}): Promise<{
+    kind: "site";
+    site: {
+        id: string;
+        name: string;
+        status: "active" | "alarm" | "inactive" | "loading" | "normal" | "offline" | "unconfigured" | "unknown" | "warning";
+        alarmUnknown: boolean;
+        maintenanceUnknown: boolean;
+        overdueMaintenance: string[];
+        overdueMaintenanceOmitted: number;
+        statusLabel: string;
+    };
+    alarms: {
+        siteId: string;
+        site: string;
+        equipment: string | null;
+        name: string;
+        severity: "critical" | "warning";
+    }[];
+    alarmsOmitted: number;
+    fleet: {
+        siteCount: number;
+        statusCounts: {
+            status: "active" | "alarm" | "inactive" | "loading" | "normal" | "offline" | "unconfigured" | "unknown" | "warning";
+            label: string;
+            count: number;
+        }[];
+        alarms: {
+            siteId: string;
+            site: string;
+            equipment: string | null;
+            name: string;
+            severity: "critical" | "warning";
+        }[];
+        alarmsOmitted: number;
+        sites: {
+            id: string;
+            name: string;
+            status: "active" | "alarm" | "inactive" | "loading" | "normal" | "offline" | "unconfigured" | "unknown" | "warning";
+            alarmUnknown: boolean;
+            maintenanceUnknown: boolean;
+            overdueMaintenance: string[];
+            overdueMaintenanceOmitted: number;
+        }[];
+        sitesOmitted: number;
+        alarmUnknownSites: number;
+        maintenanceUnknownSites: number;
+    } | null;
+}>;
+/**
+ * Publishes `readSiteSummary` of a site page for the assistant. Sites are read only when the
+ * assistant asks.
+ */
+export declare function usePublishSiteSummary<Site extends {
+    id: string;
+    name: string;
+}>({ statusLabels, ...source }: SiteSummarySource<Site> & {
+    statusLabels?: SiteStatusLabels;
+}): void;
+/**
+ * The site and the rest of the path of a site page under `sitesPath`, such as
+ * `/stations/<id>/pumps/<id>`; null for any other path. The rest is empty for the site's own page.
+ */
+export declare function matchSitePath(path: string, sitesPath: string): {
+    siteId: string;
+    rest: string;
+} | null;
+/**
+ * The pages of a fleet dashboard: `overview` at `/` and each site's page at `<sitesPath>/<id>`.
+ * Pages below a site's own, such as `/sites/<id>/points/<id>`, go to `subpage`, which returns
+ * null for one that does not exist. Without `subpage` there are none. A missing site or page
+ * shows `notFound` with a link back to the overview.
+ */
+export declare function FleetRoutes<Site extends {
+    id: string;
+}>({ navigation, sites, sitesPath, overview, site, subpage, notFound, backLabel, }: {
+    navigation: Pick<DashboardNavigation, "location" | "href" | "navigate">;
+    sites: readonly Site[];
+    /** Such as `/stations`. */
+    sitesPath: string;
+    overview: ReactNode;
+    site: (site: Site) => ReactNode;
+    subpage?: (site: Site, path: string) => ReactNode;
+    notFound: string;
+    backLabel: string;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
+export {};

package/dist/src/workspace/fleet/slot-fields.d.ts

@@ -0,0 +1,53 @@
+import type { SiteRoleFormValue, SiteRoleKind } from "@overvis/hmi-shared/dashboard";
+import { type FormFieldErrors } from "../../form/index.js";
+/**
+ * Field errors for the rows `fromForm` of a `defineSiteRoles` declaration reported invalid; `path`
+ * is where the rows are in the form, such as `roles`.
+ */
+export declare function siteSlotErrors(invalid: readonly string[], path: string): FormFieldErrors;
+/**
+ * Form rows of a `defineSiteRoles` declaration's reading and condition slots, in declaration
+ * order: a parameter per slot, a unit for readings (filled from the parameter unless typed) and
+ * a comparison and value for conditions. Place it with `fields` at the rows built by
+ * `formValue`; control slots are edited elsewhere. Map `fromForm`'s `invalid` rows to field
+ * errors with `siteSlotErrors`.
+ */
+export declare const SiteSlotFields: <TFormData, TFields extends import("@tanstack/react-form").DeepKeysOfType<TFormData, Record<string, SiteRoleFormValue> | null | undefined> | import("@tanstack/react-form").FieldsMap<TFormData, Record<string, SiteRoleFormValue>>, 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<{
+    /** The `defineSiteRoles` declaration. */
+    roles: {
+        rows: readonly {
+            key: string;
+            kind: SiteRoleKind;
+        }[];
+    };
+    /** Label of each slot by key, such as "Running condition". */
+    labels: Readonly<Record<string, string>>;
+    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>;

package/dist/src/workspace/fleet/starter-fields.d.ts

@@ -0,0 +1,63 @@
+import Type from "typebox";
+import type { SiteStarter } from "@overvis/hmi-shared/dashboard";
+import { type FormFieldErrors } from "../../form/index.js";
+import { type ParameterInfo } from "./parameters.js";
+/** Starter bindings as `SiteStarterFields` edits them: a parameter, or empty, per starter key. */
+export declare const siteStarterFormType: Type.TRecord<"^.*$", Type.TUnion<[Type.TLiteral<"">, Type.TString]>>;
+/** Empty bindings for every key that any of `starters` offers. */
+export declare function siteStarterFormValue(starters: readonly {
+    key: string;
+}[]): Record<string, string>;
+/**
+ * The starters that received a parameter, with its unit, for `starterEquipment`, or field errors
+ * under `path`, such as `starters`. A setpoint needs a writable parameter.
+ */
+export declare function siteStarterBindings<Key extends string>(starters: readonly SiteStarter<Key, string>[], value: Readonly<Record<string, string>>, path: string, parameterInfo: (parameterId: string) => Promise<ParameterInfo | "unavailable" | null>): Promise<{
+    bindings: Partial<Record<Key, {
+        parameterId: string;
+        unit: string;
+    }>>;
+    errors: FormFieldErrors;
+}>;
+/**
+ * Optional parameter pickers for the typical readings, alarms and setpoints of a new site or
+ * piece of equipment. Place it with `fields` at a `siteStarterFormValue`, collect bindings with
+ * `siteStarterBindings` and build equipment with `starterEquipment`.
+ */
+export declare const SiteStarterFields: <TFormData, TFields extends import("@tanstack/react-form").DeepKeysOfType<TFormData, Record<string, string> | null | undefined> | import("@tanstack/react-form").FieldsMap<TFormData, Record<string, string>>, 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<{
+    /** The starters offered, each with its label, such as "Door open". */
+    starters: readonly {
+        key: string;
+        label: string;
+    }[];
+    title: string;
+    hint: string;
+    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>;

package/dist/src/workspace/fleet/status-badge.d.ts

@@ -0,0 +1,23 @@
+import type { SiteStatus } from "@overvis/hmi-shared/dashboard";
+import { type SiteDueDate, type SiteState } from "./status.js";
+export type SiteStatusLabels = Partial<Record<SiteStatus, string>>;
+/** Status label: the preset's label when given, otherwise the generic one. */
+export declare function useSiteStatusLabel(labels?: SiteStatusLabels): (status: SiteStatus) => string;
+/**
+ * Status badge, activity count (such as "2/3 running"), last data time while offline, and a
+ * note when alarm feedback is unavailable. Presets relabel states through `labels`.
+ */
+export declare function SiteStatusBadge({ state, labels, activityCount, }: {
+    state: SiteState;
+    labels?: SiteStatusLabels;
+    /** Activity count text; `count` is "?" while some activity feedback is unavailable. */
+    activityCount?: (count: number | "?", total: number) => string;
+}): import("react").JSX.Element;
+/**
+ * Overdue maintenance (or, with `dueDate="verification"`, verification) of a site or its
+ * equipment; nothing while dates are due or unknown.
+ */
+export declare function SiteMaintenanceBadge({ overdue, dueDate, }: {
+    overdue: readonly string[];
+    dueDate?: SiteDueDate;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,85 @@
+import { type SiteAlarmSeverity, type SiteStatus } from "@overvis/hmi-shared/dashboard";
+import type { ParameterCondition } from "@overvis/hmi-shared/parameter";
+import { type SiteDueEquipment } from "./due-dates.js";
+import { type ParameterValueState } from "../parameters/live/model.js";
+/** Most urgent first; used for status sorting. */
+export declare const siteStatusOrder: Record<SiteStatus, number>;
+export declare function isSiteStatus(value: string): value is SiteStatus;
+export interface SiteStatusFeedback {
+    /** Activity feedback such as running or lamp-on conditions; each true one counts as active. */
+    activity: readonly ParameterCondition[];
+    alarms: readonly {
+        condition: ParameterCondition;
+        severity: SiteAlarmSeverity;
+    }[];
+}
+export interface SiteState {
+    status: SiteStatus;
+    /** Worst known active alarm. */
+    severity: SiteAlarmSeverity | null;
+    alarm: boolean;
+    /** Some activity feedback is unavailable, so `count` may be low. */
+    activityUnknown: boolean;
+    /** Some alarm feedback is unavailable; a known active alarm still decides the status. */
+    alarmUnknown: boolean;
+    /** Activity conditions known to be true. */
+    count: number;
+    /** Activity conditions configured. */
+    total: number;
+    /** Newest value received from any feedback parameter. */
+    lastData: number | null;
+}
+/**
+ * Status from activity and alarm feedback only; measurements never decide it. A known active
+ * critical alarm wins, then a warning. Unavailable activity feedback is reported as unknown, never
+ * as inactive: `loading` covers the first read; `offline` means no feedback is current, whether
+ * values are missing or only stale ones are retained (`lastData` is the newest of those); and
+ * `unknown` means some feedback is not current while the rest is. Unavailable alarm feedback
+ * sets `alarmUnknown` without hiding a known `active` or `inactive` state, which the badge shows
+ * next to it. A site without activity feedback is `normal` while no alarm is active and every
+ * alarm is known.
+ */
+export declare function evaluateSiteStatus(feedback: SiteStatusFeedback, states: ReadonlyMap<string, ParameterValueState>): SiteState;
+/** The parameters `evaluateSiteStatus` reads for `feedback`, each once. */
+export declare function siteStatusParameterIds(feedback: SiteStatusFeedback): string[];
+/**
+ * Everything a site's summary for the assistant evaluates, each once: its status feedback and
+ * the due dates of `equipment`.
+ */
+export declare function siteAttentionParameterIds(feedback: SiteStatusFeedback, equipment: readonly SiteDueEquipment[]): string[];
+/**
+ * The alarms whose condition is known to be active, critical first and otherwise in their order.
+ * An alarm without a condition, such as an unbound fault slot, is never active.
+ */
+export declare function activeAlarmsBySeverity<Alarm extends {
+    readonly condition?: ParameterCondition | undefined;
+    readonly severity: SiteAlarmSeverity;
+}>(alarms: readonly Alarm[], states: ReadonlyMap<string, ParameterValueState>): Alarm[];
+/** Badge variant of each status: red alarm, amber warning and no data, green activity. */
+export declare const siteStatusBadgeVariants: {
+    readonly alarm: "destructive";
+    readonly warning: "warning";
+    readonly offline: "warning";
+    readonly active: "success";
+    readonly normal: "success";
+    readonly inactive: "outline";
+    readonly unknown: "outline";
+    readonly loading: "outline";
+    readonly unconfigured: "outline";
+};
+/** Map marker classes; unknown states are hollow so they never read as inactive. */
+export declare const siteStatusMarkerClasses: {
+    alarm: string;
+    warning: string;
+    offline: string;
+    active: string;
+    normal: string;
+    inactive: string;
+    unknown: string;
+    loading: string;
+    unconfigured: string;
+};
+/** Cluster tone of a status on the map: the worst member colours a cluster. */
+export declare function siteStatusTone(status: SiteStatus): "critical" | "warning" | "normal";
+/** What a due date parameter tracks: maintenance, or verification (calibration) of a meter. */
+export type SiteDueDate = "maintenance" | "verification";

package/dist/src/workspace/formulas/diagnostic-text.d.ts

@@ -0,0 +1,7 @@
+import type { ExpressionDiagnostic } from "@overvis/hmi-shared/expression";
+/** A comma-separated list of type names, translated and joined for the locale. */
+export declare function formulaTypeList(types: string | number | undefined, kind: "conjunction" | "disjunction"): string;
+/** What is wrong, in the UI language. */
+export declare function formulaDiagnosticText(diagnostic: ExpressionDiagnostic): string;
+/** What is wrong and where in the formula, in the UI language. */
+export declare function formulaProblemText(diagnostic: ExpressionDiagnostic): string;

package/dist/src/workspace/graphics/actions/details.d.ts

@@ -0,0 +1,49 @@
+import { type AppLocale } from "@overvis/hmi-shared";
+import { type GraphicsConnector, type GraphicsDocument, type GraphicsElement } from "@overvis/hmi-shared/graphics";
+import type { Parameter } from "@overvis/hmi-shared/parameter";
+import type { ParameterValueSnapshot, ParameterValueState } from "../../parameters/live/model.js";
+import { type GraphicsSymbolDefinition } from "../symbols/definition.js";
+/** Parameter setup the details dialog shows besides live values. */
+export type GraphicsDetailParameter = Pick<Parameter, "name" | "units" | "valueType">;
+/** One reading in the details dialog, labelled as the symbol labels it. */
+export interface GraphicsDetailRow {
+    key: string;
+    label: string;
+    /** Formatted with units and state names; null while the reading is unavailable. */
+    value: string | null;
+    parameterId: string;
+}
+/**
+ * A reading as the parameter reports it: numbers in the locale's format with the precision the
+ * parameter reads at and its units, flags as yes or no, and value names as they are.
+ */
+export declare function formatGraphicsParameterReading(snapshot: ParameterValueSnapshot, parameter: GraphicsDetailParameter | undefined, locale: AppLocale): string;
+/**
+ * The readings of one object: each bound symbol property under the symbol's own name for it, in
+ * the symbol's order, then any other parameter the object or its groups show, under its name.
+ */
+export declare function graphicsDetailRows({ item, document, definition, parameters, states, locale, }: {
+    item: GraphicsElement | GraphicsConnector;
+    document: GraphicsDocument;
+    definition: GraphicsSymbolDefinition | undefined;
+    parameters: ReadonlyMap<string, GraphicsDetailParameter>;
+    states: ReadonlyMap<string, ParameterValueState>;
+    locale: AppLocale;
+}): GraphicsDetailRow[];
+/**
+ * The dialog's heading: the tag the drawing shows on the symbol, or the object's name, then the
+ * name and the kind of symbol when they add to it.
+ */
+export declare function graphicsDetailHeading(item: GraphicsElement | GraphicsConnector, definition: GraphicsSymbolDefinition | undefined, 
+/** The drawing's language, which a localized tag is shown in. */
+locale: AppLocale, 
+/** An action's dialog, such as a setpoint, is about its value, not about the control. */
+action?: boolean): {
+    title: string;
+    subtitle: string[];
+};
+/** Write limits a parameter declares, for numeric values. */
+export declare function graphicsWriteRange(parameter: GraphicsDetailParameter | undefined): {
+    min: number | null;
+    max: number | null;
+};

package/dist/src/workspace/graphics/actions/dialog.d.ts

@@ -0,0 +1,12 @@
+import { type GraphicsActionSelection } from "./selection.js";
+import { type GraphicsDocument } from "@overvis/hmi-shared/graphics";
+import { type ParameterValueState } from "../../parameters/live/model.js";
+/** Readings and actions of one object; drawings are light-only, and so is what they open. */
+export declare function GraphicsActionDialog({ workspaceId, selection, document, states, allowWrites, onClose, }: {
+    workspaceId: string;
+    selection: GraphicsActionSelection | null;
+    document: GraphicsDocument;
+    states: ReadonlyMap<string, ParameterValueState>;
+    allowWrites: boolean;
+    onClose: () => void;
+}): import("react").JSX.Element | null;