@devicechain/widgets 0.21.1 → 0.22.0-rc.1

package/dist/level-reading.d.ts

@@ -0,0 +1,29 @@
+import { type MeasurementStreamState, type SeverityLevel, type Threshold } from '@devicechain/widget-sdk';
+import type { MeasurementSample, WidgetInstance } from '@devicechain/dashboards';
+import { type LevelStrings } from './level-strings';
+import { type Fill, type RangeResult } from './value-scale';
+export interface LevelReading {
+    name: string | undefined;
+    sample: MeasurementSample | undefined;
+    value: number | undefined;
+    unit: string | undefined;
+    precision: number | undefined;
+    display: string;
+    thresholds: Threshold[];
+    band: Threshold | undefined;
+    levelColor: string | undefined;
+    colorOf: (level: SeverityLevel | undefined) => string | undefined;
+    fillColor: string;
+    range: RangeResult | undefined;
+    fill: Fill | undefined;
+    strings: LevelStrings;
+}
+export interface LevelInput {
+    thresholds: Threshold[];
+    unit: string | undefined;
+    precision: number | undefined;
+    range?: RangeResult;
+    normalize?: (raw: number | undefined) => number | undefined;
+}
+export declare function useLevelReading(widget: WidgetInstance, data: MeasurementStreamState, input: LevelInput): LevelReading;
+export declare function emptyReason(r: LevelReading): string | undefined;

package/dist/level-readout.d.ts

@@ -0,0 +1,25 @@
+import type { LevelStrings } from './level-strings';
+import type { ScalePosition } from './value-scale';
+export interface ReadoutRoom {
+    size: {
+        width: number;
+        height: number;
+    };
+    scale: number;
+}
+export type MarkerStrings = Pick<LevelStrings, 'aboveScale' | 'belowScale'>;
+export type LevelReadoutProps = ReadoutRoom & {
+    text: string;
+    unit?: string;
+    color?: string;
+} & ({
+    position?: ScalePosition;
+    strings: MarkerStrings;
+} | {
+    position?: undefined;
+    strings?: undefined;
+});
+export declare function LevelReadout({ text, unit, color, position, size, scale, strings }: LevelReadoutProps): import("react").JSX.Element;
+export declare function LevelEmpty({ message }: {
+    message: string;
+}): import("react").JSX.Element;

package/dist/level-strings.d.ts

@@ -0,0 +1,13 @@
+export interface LevelStrings {
+    noData: string;
+    setRange: string;
+    badRange: string;
+    setThresholds: string;
+    aboveScale: string;
+    belowScale: string;
+    on: string;
+    off: string;
+    cardinals: readonly [string, string, string, string];
+}
+export declare const LEVEL_STRINGS: Record<'en' | 'es', LevelStrings>;
+export declare function levelStrings(locale?: string | undefined): LevelStrings;

package/dist/options.d.ts

@@ -1,6 +1,6 @@
 import { clampNumberOption, type NumberOptionSpec, type OptionIssueCode, type BuiltinWidgetId, type OptionsOf, type WidgetType } from '@devicechain/dashboards';
 import { builtinWidgetDescriptors } from './builtin-descriptors';
-export type { BooleanOptionSpec, EnumOptionSpec, NumberOptionSpec, OptionIssueCode, OptionSpec, StringOptionSpec, WidgetOptionSpecs, } from '@devicechain/dashboards';
+export type { BooleanOptionSpec, EnumOptionSpec, ListItemFieldSpec, ListOptionSpec, NumberOptionSpec, OptionIssueCode, OptionSpec, StringOptionSpec, WidgetOptionSpecs, } from '@devicechain/dashboards';
 export { clampNumberOption };
 type OptionsById = {
     readonly [K in BuiltinWidgetId]: (typeof builtinWidgetDescriptors)[K]['options'];

package/dist/time-range-bar.d.ts

@@ -0,0 +1,28 @@
+import { type TimeRangeState } from '@devicechain/dashboards';
+export interface TimeRangeControls {
+    setSpan(spanSeconds: number): void;
+    pause(): void;
+    resume(): void;
+}
+export declare function useBoardTimeRange(defaultSeconds: number | undefined, link?: {
+    spanSeconds?: number;
+    paused?: boolean;
+}): [TimeRangeState, TimeRangeControls];
+export interface TimeRangeLabels {
+    range: string;
+    pause: string;
+    resume: string;
+    paused: string;
+    pausedAt: (time: string) => string;
+    actionsLive: string;
+}
+export declare const DEFAULT_TIME_RANGE_LABELS: TimeRangeLabels;
+export declare function PausedIndicator({ pausedAt, labels, }: {
+    pausedAt: number | undefined;
+    labels?: TimeRangeLabels;
+}): import("react").JSX.Element;
+export declare function TimeRangeBar({ state, controls, labels, }: {
+    state: TimeRangeState;
+    controls: TimeRangeControls;
+    labels?: TimeRangeLabels;
+}): import("react").JSX.Element;

package/dist/use-held.d.ts

@@ -0,0 +1 @@
+export declare function useHeld<T>(value: T, hold: boolean, ready: (v: T) => boolean): T;

package/dist/value-scale.d.ts

@@ -0,0 +1,30 @@
+import { type SeverityLevel, type Threshold } from '@devicechain/widget-sdk';
+export interface ScaleRange {
+    min: number;
+    max: number;
+}
+export type RangeResult = {
+    ok: true;
+    range: ScaleRange;
+} | {
+    ok: false;
+    reason: 'missing' | 'invalid';
+};
+export declare function readRange(configuredMin: number | undefined, configuredMax: number | undefined, fallback?: ScaleRange): RangeResult;
+export type ScalePosition = 'below' | 'within' | 'above';
+export interface Fill {
+    fraction: number;
+    position: ScalePosition;
+    ratio: number;
+}
+export declare function fillOf(value: number | null | undefined, range: ScaleRange): Fill | undefined;
+export interface BandSpan {
+    from: number;
+    to: number;
+    level: SeverityLevel | undefined;
+}
+export declare function bandSpans(thresholds: readonly Threshold[], range: ScaleRange): BandSpan[];
+export declare function litBars(thresholds: readonly Threshold[], value: number | null | undefined): {
+    total: number;
+    lit: number;
+} | undefined;

package/dist/widgets/aggregate-lazy.d.ts

@@ -0,0 +1,305 @@
+export declare const loadAggregateWidgets: () => Promise<typeof import("./aggregate-widgets")>;
+export declare const statCardWidget: import("@devicechain/widget-sdk").WidgetDefinition<"aggregate", {
+    readonly title: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelTitle';
+        readonly doc: 'Heading shown in the widget frame. Defaults to the displayed measurement name.';
+    };
+    readonly measurement: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelMeasurement';
+        readonly helpId: 'widgetHintMeasurement';
+        readonly doc: 'Which measurement to display. Defaults to the first the datasource selects.';
+    };
+    readonly stat: {
+        readonly kind: "enum";
+        readonly values: readonly ["avg", "min", "max", "sum", "count", "last"];
+        readonly labelId: "widgetLabelStat";
+        readonly helpId: "widgetHintStat";
+        readonly valueLabelIds: {
+            readonly avg: "widgetStatAvg";
+            readonly min: "widgetStatMin";
+            readonly max: "widgetStatMax";
+            readonly sum: "widgetStatSum";
+            readonly count: "widgetStatCount";
+            readonly last: "widgetStatLast";
+        };
+        readonly placeholderId: "widgetPlaceholderDefault";
+        readonly doc: "Which figure to show. Default average.";
+    };
+    readonly unit: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelUnit';
+        readonly doc: 'Unit suffix shown beside the value.';
+    };
+    readonly precision: {
+        readonly kind: 'number';
+        readonly integer: true;
+        readonly min: 0;
+        readonly max: 100;
+        readonly labelId: 'widgetLabelPrecision';
+        readonly helpId: 'widgetHintPrecision';
+        readonly doc: 'Decimal places to round displayed values to. Unset rounds to at most 3 decimals (4 significant digits under 1).';
+    };
+    readonly thresholds: {
+        readonly kind: 'list';
+        readonly maxItems: 12;
+        readonly labelId: 'widgetLabelThresholds';
+        readonly helpId: 'widgetHintThresholds';
+        readonly doc: 'Severity bands over the value. Each entry starts a band at its value that runs to the next entry; below the first, and in a normal band, the widget keeps its own colour.';
+        readonly item: {
+            readonly value: {
+                readonly kind: 'number';
+                readonly required: true;
+                readonly labelId: 'widgetLabelThresholdValue';
+                readonly doc: 'The value at which this band starts.';
+            };
+            readonly level: {
+                readonly kind: 'enum';
+                readonly required: true;
+                readonly values: readonly ["normal", "warning", "minor", "major", "critical"];
+                readonly labelId: 'widgetLabelThresholdLevel';
+                readonly valueLabelIds: {
+                    readonly normal: 'widgetSeverityNormal';
+                    readonly warning: 'widgetSeverityWarning';
+                    readonly minor: 'widgetSeverityMinor';
+                    readonly major: 'widgetSeverityMajor';
+                    readonly critical: 'widgetSeverityCritical';
+                };
+                readonly placeholderId: 'widgetPlaceholderThresholdLevel';
+                readonly doc: 'The severity of this band. The theme decides the colour; normal has none.';
+            };
+            readonly label: {
+                readonly kind: 'string';
+                readonly labelId: 'widgetLabelThresholdLabel';
+                readonly doc: 'Text shown on the chart line for this threshold. Defaults to its value.';
+            };
+        };
+    };
+    readonly windowSeconds: {
+        readonly kind: 'number';
+        readonly integer: true;
+        readonly min: 60;
+        readonly max: 604800;
+        readonly labelId: 'widgetLabelWindowSeconds';
+        readonly helpId: 'widgetHintWindowSeconds';
+        readonly doc: 'Seconds of history the widget covers, back from now. Leave unset to follow the board’s time range; set it to pin this widget to a fixed span that the viewer’s range picker does not change. 60 to 604800.';
+    };
+}>;
+export declare const barChartWidget: import("@devicechain/widget-sdk").WidgetDefinition<"measurement", {
+    readonly title: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelTitle';
+        readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+    };
+    readonly groupBy: {
+        readonly kind: "enum";
+        readonly values: readonly ["measurement", "device"];
+        readonly labelId: "widgetLabelGroupBy";
+        readonly helpId: "widgetHintGroupBy";
+        readonly valueLabelIds: {
+            readonly measurement: "widgetGroupByMeasurement";
+            readonly device: "widgetGroupByDevice";
+        };
+        readonly placeholderId: "widgetPlaceholderDefault";
+        readonly doc: "One bar per measurement (the default), or per device of the group for the measurement set below.";
+    };
+    readonly measurement: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelMeasurement';
+        readonly helpId: 'widgetHintMeasurement';
+        readonly doc: 'Which measurement to display. Defaults to the first the datasource selects.';
+    };
+    readonly unit: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelUnit';
+        readonly doc: 'Unit suffix shown beside the value.';
+    };
+    readonly precision: {
+        readonly kind: 'number';
+        readonly integer: true;
+        readonly min: 0;
+        readonly max: 100;
+        readonly labelId: 'widgetLabelPrecision';
+        readonly helpId: 'widgetHintPrecision';
+        readonly doc: 'Decimal places to round displayed values to. Unset rounds to at most 3 decimals (4 significant digits under 1).';
+    };
+    readonly sort: {
+        readonly kind: 'enum';
+        readonly values: readonly ["none", "ascending", "descending"];
+        readonly labelId: 'widgetLabelSort';
+        readonly valueLabelIds: {
+            readonly none: 'widgetSortNone';
+            readonly ascending: 'widgetSortAscending';
+            readonly descending: 'widgetSortDescending';
+        };
+        readonly placeholderId: 'widgetPlaceholderDefault';
+        readonly doc: 'Order of the categories. Default: as the data source lists them.';
+    };
+}>;
+export declare const pieChartWidget: import("@devicechain/widget-sdk").WidgetDefinition<"measurement", {
+    readonly title: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelTitle';
+        readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+    };
+    readonly unit: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelUnit';
+        readonly doc: 'Unit suffix shown beside the value.';
+    };
+    readonly precision: {
+        readonly kind: 'number';
+        readonly integer: true;
+        readonly min: 0;
+        readonly max: 100;
+        readonly labelId: 'widgetLabelPrecision';
+        readonly helpId: 'widgetHintPrecision';
+        readonly doc: 'Decimal places to round displayed values to. Unset rounds to at most 3 decimals (4 significant digits under 1).';
+    };
+    readonly sort: {
+        readonly kind: 'enum';
+        readonly values: readonly ["none", "ascending", "descending"];
+        readonly labelId: 'widgetLabelSort';
+        readonly valueLabelIds: {
+            readonly none: 'widgetSortNone';
+            readonly ascending: 'widgetSortAscending';
+            readonly descending: 'widgetSortDescending';
+        };
+        readonly placeholderId: 'widgetPlaceholderDefault';
+        readonly doc: 'Order of the categories. Default: as the data source lists them.';
+    };
+}>;
+export declare const fleetTableWidget: import("@devicechain/widget-sdk").WidgetDefinition<"measurement", {
+    readonly title: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelTitle';
+        readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+    };
+    readonly columns: {
+        readonly kind: 'list';
+        readonly maxItems: 24;
+        readonly labelId: 'widgetLabelColumns';
+        readonly helpId: 'widgetHintColumns';
+        readonly doc: 'Heading, unit and precision per measurement column; a column with none shows its name.';
+        readonly item: {
+            readonly measurement: {
+                readonly kind: 'string';
+                readonly required: true;
+                readonly labelId: 'widgetLabelMeasurement';
+                readonly doc: 'The measurement column this entry applies to.';
+            };
+            readonly label: {
+                readonly kind: 'string';
+                readonly labelId: 'widgetLabelColumnHeading';
+                readonly doc: 'Column heading. Defaults to the measurement name.';
+            };
+            readonly unit: {
+                readonly kind: 'string';
+                readonly labelId: 'widgetLabelUnit';
+                readonly doc: 'Unit suffix shown beside the value.';
+            };
+            readonly precision: {
+                readonly kind: 'number';
+                readonly integer: true;
+                readonly min: 0;
+                readonly max: 100;
+                readonly labelId: 'widgetLabelPrecision';
+                readonly helpId: 'widgetHintPrecision';
+                readonly doc: 'Decimal places to round displayed values to. Unset rounds to at most 3 decimals (4 significant digits under 1).';
+            };
+        };
+    };
+    readonly thresholds: {
+        readonly kind: 'list';
+        readonly maxItems: 12;
+        readonly labelId: 'widgetLabelThresholds';
+        readonly helpId: 'widgetHintThresholds';
+        readonly doc: 'Severity bands over the value. Each entry starts a band at its value that runs to the next entry; below the first, and in a normal band, the widget keeps its own colour.';
+        readonly item: {
+            readonly value: {
+                readonly kind: 'number';
+                readonly required: true;
+                readonly labelId: 'widgetLabelThresholdValue';
+                readonly doc: 'The value at which this band starts.';
+            };
+            readonly level: {
+                readonly kind: 'enum';
+                readonly required: true;
+                readonly values: readonly ["normal", "warning", "minor", "major", "critical"];
+                readonly labelId: 'widgetLabelThresholdLevel';
+                readonly valueLabelIds: {
+                    readonly normal: 'widgetSeverityNormal';
+                    readonly warning: 'widgetSeverityWarning';
+                    readonly minor: 'widgetSeverityMinor';
+                    readonly major: 'widgetSeverityMajor';
+                    readonly critical: 'widgetSeverityCritical';
+                };
+                readonly placeholderId: 'widgetPlaceholderThresholdLevel';
+                readonly doc: 'The severity of this band. The theme decides the colour; normal has none.';
+            };
+            readonly label: {
+                readonly kind: 'string';
+                readonly labelId: 'widgetLabelThresholdLabel';
+                readonly doc: 'Text shown on the chart line for this threshold. Defaults to its value.';
+            };
+            readonly measurement: {
+                readonly kind: 'string';
+                readonly required: true;
+                readonly labelId: 'widgetLabelMeasurement';
+                readonly doc: 'The measurement column this entry applies to.';
+            };
+        };
+    };
+    readonly staleAfterSeconds: {
+        readonly kind: 'number';
+        readonly integer: true;
+        readonly min: 1;
+        readonly labelId: 'widgetLabelStaleAfter';
+        readonly helpId: 'widgetHintStaleAfter';
+        readonly doc: 'Seconds after which the newest sample is called stale: the value is greyed out and badged. Unset shows the sample age only and never marks the widget stale.';
+    };
+    readonly ageLagSeconds: {
+        readonly kind: "number";
+        readonly integer: true;
+        readonly min: 1;
+        readonly labelId: "widgetLabelAgeLag";
+        readonly helpId: "widgetHintAgeLag";
+        readonly doc: "Show a reading's age under it only when the reading is at least this many seconds older than the newest reading in the table (or stale). Unset shows every reading's age.";
+    };
+    readonly sortBy: {
+        readonly kind: "string";
+        readonly labelId: "widgetLabelSortBy";
+        readonly helpId: "widgetHintSortBy";
+        readonly doc: "The measurement the table is ordered by. Blank orders by device name.";
+    };
+    readonly sortDescending: {
+        readonly kind: "boolean";
+        readonly labelId: "widgetLabelSortDescending";
+        readonly doc: "Largest first.";
+    };
+    readonly pageSize: {
+        readonly kind: "number";
+        readonly integer: true;
+        readonly min: 5;
+        readonly max: 100;
+        readonly labelId: "widgetLabelPageSize";
+        readonly doc: "Devices per page. Default 20.";
+    };
+    readonly selectionTarget: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelTargetSlot';
+        readonly helpId: 'widgetTargetSlotHint';
+        readonly control: 'slot-target';
+        readonly doc: 'Name of the slot this widget re-points when the viewer picks an entity.';
+    };
+    readonly windowSeconds: {
+        readonly kind: 'number';
+        readonly integer: true;
+        readonly min: 60;
+        readonly max: 604800;
+        readonly labelId: 'widgetLabelWindowSeconds';
+        readonly helpId: 'widgetHintWindowSeconds';
+        readonly doc: 'Seconds of history the widget covers, back from now. Leave unset to follow the board’s time range; set it to pin this widget to a fixed span that the viewer’s range picker does not change. 60 to 604800.';
+    };
+}>;

package/dist/widgets/aggregate-widgets.d.ts

@@ -0,0 +1,4 @@
+export { BarChart } from './bar-chart';
+export { FleetTable } from './fleet-table';
+export { PieChart } from './pie-chart';
+export { StatCard } from './stat-card';

package/dist/widgets/alarm-count.d.ts

@@ -1,4 +1,5 @@
 import { type AlarmStreamState, type WidgetProps } from '@devicechain/widget-sdk';
+export declare const ALARM_COUNT_CAPTION_ROOM_PX = 20;
 export declare function AlarmCount({ widget, data }: WidgetProps<AlarmStreamState>): import("react").JSX.Element;
 export declare const alarmCountWidget: import("@devicechain/widget-sdk").WidgetDefinition<"alarm", {
     readonly title: {

package/dist/widgets/alarm-table.d.ts

@@ -1,4 +1,7 @@
+import { type ReactNode } from 'react';
 import { type AlarmStreamState, type WidgetProps } from '@devicechain/widget-sdk';
+export declare const ALARM_TABLE_NARROW_PX = 480;
+export declare function hyphenBreaks(text: string): ReactNode;
 export declare function AlarmTable({ widget, data, actions }: WidgetProps<AlarmStreamState>): import("react").JSX.Element;
 export declare const alarmTableWidget: import("@devicechain/widget-sdk").WidgetDefinition<"alarm", {
     readonly title: {
@@ -60,7 +63,7 @@ export declare const alarmTableWidget: import("@devicechain/widget-sdk").WidgetD
         readonly max: 100;
         readonly labelId: 'widgetLabelPrecision';
         readonly helpId: 'widgetHintPrecision';
-        readonly doc: 'Decimal places to round displayed values to. Unset shows the raw value.';
+        readonly doc: 'Decimal places to round displayed values to. Unset rounds to at most 3 decimals (4 significant digits under 1).';
     };
     readonly flashOnChange: {
         readonly kind: 'boolean';

package/dist/widgets/bar-chart.d.ts

@@ -0,0 +1,5 @@
+import { type WidgetProps } from '@devicechain/widget-sdk';
+export declare const MAX_LABELLED_BARS = 12;
+export declare const MAX_DEVICE_BARS = 100;
+export declare function BarChart({ widget, data }: WidgetProps): import("react").JSX.Element;
+export declare function fitLabel(label: string, chars: number): string;

package/dist/widgets/battery.d.ts

@@ -0,0 +1,7 @@
+import { type WidgetProps } from '@devicechain/widget-sdk';
+export declare const BATTERY_DEFAULT_RANGE: {
+    readonly min: 0;
+    readonly max: 100;
+};
+export declare const BATTERY_FILL_WIDTH: number;
+export declare function Battery({ widget, data }: WidgetProps): import("react").JSX.Element;

package/dist/widgets/command-slider.d.ts

@@ -0,0 +1,2 @@
+import { type CommandStreamState, type WidgetProps } from '@devicechain/widget-sdk';
+export declare function CommandSlider({ widget, data, actions }: WidgetProps<CommandStreamState>): import("react").JSX.Element;

package/dist/widgets/command-toggle.d.ts

@@ -0,0 +1,4 @@
+import { type CommandStreamState, type WidgetProps } from '@devicechain/widget-sdk';
+import { type LastSent } from '../command-control-core';
+export declare function CommandToggle({ widget, data, actions }: WidgetProps<CommandStreamState>): import("react").JSX.Element;
+export declare function intentOf(last: LastSent | null): boolean | undefined;

package/dist/widgets/compass.d.ts

@@ -0,0 +1,2 @@
+import { type WidgetProps } from '@devicechain/widget-sdk';
+export declare function Compass({ widget, data }: WidgetProps): import("react").JSX.Element;

package/dist/widgets/control-lazy.d.ts

@@ -0,0 +1,92 @@
+export declare const loadControlWidgets: () => Promise<typeof import("./control-widgets")>;
+export declare const commandSliderWidget: import("@devicechain/widget-sdk").WidgetDefinition<"control", {
+    readonly title: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelTitle';
+        readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+    };
+    readonly commandName: {
+        readonly kind: 'string';
+        readonly required: true;
+        readonly labelId: 'widgetCommandHeading';
+        readonly helpId: 'widgetCommandFieldHint';
+        readonly control: 'command-vocabulary';
+        readonly doc: 'Command key issued to the target device. Without it the control cannot send.';
+    };
+    readonly commandLabel: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetCommandHeading';
+        readonly helpId: 'widgetCommandFieldHint';
+        readonly control: 'command-vocabulary';
+        readonly doc: 'Name of the control for assistive technology. Defaults to the command key.';
+    };
+    readonly parameterSchema: {
+        readonly kind: 'string';
+        readonly format: 'json';
+        readonly labelId: 'widgetCommandHeading';
+        readonly helpId: 'widgetCommandFieldHint';
+        readonly control: 'command-vocabulary';
+        readonly doc: "The command's parameter descriptors, baked in as JSON at author time. Gives the control its range and its refusals.";
+    };
+    readonly parameter: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelParameter';
+        readonly helpId: 'widgetHintControlParameter';
+        readonly doc: 'Which parameter of the command this control sets. May be left blank when the command has exactly one parameter of the right type.';
+    };
+    readonly min: {
+        readonly kind: "number";
+        readonly labelId: "widgetLabelMin";
+        readonly helpId: "widgetHintSliderRange";
+        readonly doc: "Lowest value, used only when the command's parameter declares no minimum.";
+    };
+    readonly max: {
+        readonly kind: "number";
+        readonly labelId: "widgetLabelMax";
+        readonly helpId: "widgetHintSliderRange";
+        readonly doc: "Highest value, used only when the command's parameter declares no maximum.";
+    };
+    readonly step: {
+        readonly kind: "number";
+        readonly min: 0;
+        readonly labelId: "widgetLabelStep";
+        readonly helpId: "widgetHintSliderStep";
+        readonly doc: "Distance between values. Defaults to 1 for a whole-number parameter, else a hundredth of the range.";
+    };
+}>;
+export declare const commandToggleWidget: import("@devicechain/widget-sdk").WidgetDefinition<"control", {
+    readonly title: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelTitle';
+        readonly doc: 'Heading shown in the widget frame. Blank hides the frame heading.';
+    };
+    readonly commandName: {
+        readonly kind: 'string';
+        readonly required: true;
+        readonly labelId: 'widgetCommandHeading';
+        readonly helpId: 'widgetCommandFieldHint';
+        readonly control: 'command-vocabulary';
+        readonly doc: 'Command key issued to the target device. Without it the control cannot send.';
+    };
+    readonly commandLabel: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetCommandHeading';
+        readonly helpId: 'widgetCommandFieldHint';
+        readonly control: 'command-vocabulary';
+        readonly doc: 'Name of the control for assistive technology. Defaults to the command key.';
+    };
+    readonly parameterSchema: {
+        readonly kind: 'string';
+        readonly format: 'json';
+        readonly labelId: 'widgetCommandHeading';
+        readonly helpId: 'widgetCommandFieldHint';
+        readonly control: 'command-vocabulary';
+        readonly doc: "The command's parameter descriptors, baked in as JSON at author time. Gives the control its range and its refusals.";
+    };
+    readonly parameter: {
+        readonly kind: 'string';
+        readonly labelId: 'widgetLabelParameter';
+        readonly helpId: 'widgetHintControlParameter';
+        readonly doc: 'Which parameter of the command this control sets. May be left blank when the command has exactly one parameter of the right type.';
+    };
+}>;

package/dist/widgets/control-widgets.d.ts

@@ -0,0 +1,2 @@
+export { CommandSlider } from './command-slider';
+export { CommandToggle } from './command-toggle';

package/dist/widgets/fleet-table.d.ts

@@ -0,0 +1,13 @@
+import type { FleetMember } from '@devicechain/dashboards';
+import { type Threshold, type WidgetProps } from '@devicechain/widget-sdk';
+interface ColumnFormat {
+    label?: string;
+    unit?: string;
+    precision?: number;
+}
+export declare function columnFormats(raw: unknown): Map<string, ColumnFormat>;
+export declare function columnBands(raw: unknown): Map<string, Threshold[]>;
+export declare function FleetTable({ widget, data }: WidgetProps): import("react").JSX.Element;
+export declare const STACK_BELOW_PX = 480;
+export declare function newestShown(members: readonly FleetMember[], columns: readonly string[]): number | undefined;
+export {};