@devicechain/dashboards 0.21.1 → 0.22.0-rc.1

package/dist/is-record.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(v: unknown): v is Record<string, unknown>;

package/dist/layout-lint.d.ts

@@ -0,0 +1,24 @@
+import type { DashboardDefinition, WidgetInstance } from './types';
+import { type WidgetLayoutSpec, type WidgetSpan } from './widget-descriptor';
+export type LayoutLintSeverity = 'error' | 'warning' | 'info';
+export type LayoutLintCode = 'span-out-of-limits' | 'overrun-columns' | 'relative-off-canvas' | 'no-layout-declared' | 'title-duplicates-subtitle';
+export interface LayoutFinding {
+    code: LayoutLintCode;
+    severity: LayoutLintSeverity;
+    widgetId: string;
+    message: string;
+    breakpoint?: string;
+}
+export declare const PUBLISH_BLOCKING_LAYOUT_CODES: readonly LayoutLintCode[];
+export declare function blockingLayoutFindings(findings: readonly LayoutFinding[]): LayoutFinding[];
+export interface SpanLimits {
+    minSpan?: Partial<WidgetSpan>;
+    maxSpan?: Partial<WidgetSpan>;
+}
+export interface LayoutLintOptions {
+    columns: number;
+    spanLimitsOf: (widget: WidgetInstance) => SpanLimits | undefined;
+}
+export declare function spanLimitsOfLayout(layout: WidgetLayoutSpec | undefined): SpanLimits | undefined;
+export declare const RELATIVE_PROBE_CELLS: (minCellSize: number) => number[];
+export declare function lintLayout(def: DashboardDefinition, options: LayoutLintOptions): LayoutFinding[];

package/dist/legacy-grid.d.ts

@@ -0,0 +1,4 @@
+export declare const GRID_SCHEMA_VERSION = 2;
+export declare const LEGACY_REFERENCE_WIDTH = 1366;
+export declare function storedSchemaVersion(raw: Record<string, unknown>): number;
+export declare function convertLegacyDefinition(raw: Record<string, unknown>): Record<string, unknown>;

package/dist/legacy-window.d.ts

@@ -0,0 +1,5 @@
+export interface WindowConversion {
+    doc: Record<string, unknown>;
+    flagged: number[];
+}
+export declare function convertSampleWindows(raw: Record<string, unknown>): WindowConversion;

package/dist/members.d.ts

@@ -0,0 +1,36 @@
+import type { MeasurementBucket } from './queries';
+import type { MeasurementSample } from './types';
+export interface MemberRef {
+    token: string;
+    name: string | null;
+}
+export interface MemberRoster {
+    members: MemberRef[];
+    total: number;
+    unbound: boolean;
+}
+export interface MemberSink {
+    roster(roster: MemberRoster): void;
+    next(sample: MeasurementSample): void;
+    forbidden?(): void;
+    error?(err: unknown): void;
+}
+export type SeedFailure = 'forbidden' | 'failed';
+export interface MemberBucketCriteria {
+    startTime: string;
+    endTime: string;
+    intervalSeconds: number;
+    name?: string;
+}
+export type MemberBucketRead = (criteria: MemberBucketCriteria) => Promise<MeasurementBucket[]>;
+export interface MemberSeedPlan {
+    seed(deviceToken: string, read: MemberBucketRead): Promise<MemberSeed>;
+}
+export interface MemberSeed {
+    latest: Record<string, MeasurementSample>;
+    observed: string[];
+    unread?: string[];
+}
+export declare const MEMBER_SEED_CONCURRENCY = 6;
+export declare const SEED_CANCELLED: unique symbol;
+export declare function createLimiter(max: number): <T>(task: () => Promise<T>, cancelled?: () => boolean) => Promise<T>;

package/dist/option-schema.d.ts

@@ -30,7 +30,13 @@ export interface EnumOptionSpec<V extends string = string> extends OptionSpecBas
     placeholder?: string;
     placeholderId?: string;
 }
-export type OptionSpec = StringOptionSpec | NumberOptionSpec | BooleanOptionSpec | EnumOptionSpec;
+export type ListItemFieldSpec = StringOptionSpec | NumberOptionSpec | BooleanOptionSpec | EnumOptionSpec;
+export interface ListOptionSpec extends OptionSpecBase {
+    kind: 'list';
+    item: Readonly<Record<string, ListItemFieldSpec>>;
+    maxItems?: number;
+}
+export type OptionSpec = StringOptionSpec | NumberOptionSpec | BooleanOptionSpec | EnumOptionSpec | ListOptionSpec;
 export type WidgetOptionSpecs = Record<string, OptionSpec>;
 export interface GreaterThanConstraint<K extends string = string> {
     kind: 'greater-than';
@@ -39,6 +45,9 @@ export interface GreaterThanConstraint<K extends string = string> {
 }
 export type OptionConstraint<K extends string = string> = GreaterThanConstraint<K>;
 export type SpecValue<S> = S extends {
+    kind: 'list';
+    item: infer I;
+} ? OptionsOf<I>[] : S extends {
     kind: 'enum';
     values: readonly (infer V)[];
 } ? V extends string ? V : never : S extends {

package/dist/queries.d.ts

@@ -6,6 +6,9 @@ export interface EntityRelationshipsResult {
                 token: string;
             };
         }>;
+        pagination?: {
+            totalRecords: number | null;
+        } | null;
     };
 }
 export interface EntityRelationshipsVariables {
@@ -28,6 +31,13 @@ export interface DevicesByTokenVariables {
     tokens: string[];
 }
 export declare const DEVICES_BY_TOKEN: TypedDocument<DevicesByTokenResult, DevicesByTokenVariables>;
+export interface DeviceNamesResult {
+    devicesByToken: Array<{
+        token: string;
+        name: string | null;
+    }>;
+}
+export declare const DEVICE_NAMES: TypedDocument<DeviceNamesResult, DevicesByTokenVariables>;
 export interface EntityListResult {
     results: Array<{
         token: string;
@@ -56,6 +66,10 @@ export interface MeasurementBucket {
     bucketStart: string;
     name: string;
     avg: number | null;
+    min?: number | null;
+    max?: number | null;
+    sum?: number | null;
+    count?: number;
 }
 export interface BucketedMeasurementsResult {
     bucketedMeasurements: MeasurementBucket[];

package/dist/recorded.d.ts

@@ -1,6 +1,7 @@
 import type { AlarmStreamSink, AlarmSubscription, CommandStreamSink, CommandSubscription, DeviceResolver, LocationStreamSink, LocationSubscription, WidgetDataSource, WidgetStreamSink } from './hub';
 import type { AnchorTarget, DatasourceSelector, EntityCandidateLister } from './types';
 import { type BoardRecording } from './recording';
+import type { MemberSeed, MemberSeedPlan, MemberSink } from './members';
 export declare const RECORDED_HISTORY_WINDOW_MS: number;
 export type RecordedChannel = 'measurements' | 'alarms' | 'locations' | 'commands';
 export declare class NotInRecordingError extends Error {
@@ -66,12 +67,15 @@ export declare class RecordedDataSource implements WidgetDataSource {
     private stale;
     constructor(rec: BoardRecording, clock: RecordedClock, options?: RecordedSiteOptions);
     get isStale(): boolean;
+    now(): number;
     private onClock;
     private iso;
     private open;
     private resolve;
     private failLater;
     subscribeWidget(datasource: DatasourceSelector, sink: WidgetStreamSink): () => void;
+    subscribeMembers(datasource: DatasourceSelector, sink: MemberSink): () => void;
+    readMemberSeeds(deviceTokens: readonly string[], _plan: MemberSeedPlan, onSeed: (deviceToken: string, seed: MemberSeed | null) => void): Promise<void>;
     subscribeAlarms(subscription: AlarmSubscription, sink: AlarmStreamSink): () => void;
     subscribeCommands(_subscription: CommandSubscription, sink: CommandStreamSink): () => void;
     subscribeLocations(subscription: LocationSubscription, sink: LocationStreamSink): () => void;

package/dist/reflow.d.ts

@@ -0,0 +1,26 @@
+import type { SpanLimits } from './layout-lint';
+import type { CanvasGrid, DashboardDefinition, GridPlacement, WidgetInstance } from './types';
+export declare function liveColumns(grid: CanvasGrid, containerWidth: number, authored: number, scale?: number): number;
+export interface ReflowItem {
+    id: string;
+    placement: GridPlacement;
+    limits?: SpanLimits;
+}
+export declare const STACK_BELOW_WIDTH = 600;
+export declare function reflowGrid(items: readonly ReflowItem[], columns: number, options?: {
+    stack?: boolean;
+}): Map<string, GridPlacement>;
+export interface LayoutShape {
+    breakpoint: string;
+    columns: number;
+    reflowed: boolean;
+    stacked: boolean;
+}
+export declare function layoutShape(canvas: Pick<DashboardDefinition['canvas'], 'grid' | 'breakpoints'>, containerWidth: number, scale?: number): LayoutShape;
+export interface EffectiveLayout extends LayoutShape {
+    grid: Map<string, GridPlacement>;
+}
+export declare function effectiveLayout(def: DashboardDefinition, containerWidth: number, options?: {
+    scale?: number;
+    limitsOf?: (w: WidgetInstance) => SpanLimits | undefined;
+}): EffectiveLayout;

package/dist/resolver.d.ts

@@ -1,2 +1,3 @@
 import type { DeviceResolver } from './hub';
+export declare const ANCHOR_PAGE_SIZE = 500;
 export declare function createDeviceResolver(): DeviceResolver;

package/dist/same-label.d.ts

@@ -0,0 +1 @@
+export declare function sameLabel(a: string | null | undefined, b: string | null | undefined): boolean;

package/dist/slots.d.ts

@@ -1,5 +1,6 @@
-import { type AnchorTarget, type DashboardDefinition, type LocationSelection, type SlotBinding, type SlotScope, type WidgetInstance } from './types';
+import { type AnchorTarget, type DashboardDefinition, type LocationSelection, type SlotBinding, type SlotDefinition, type SlotScope, type WidgetInstance } from './types';
 export declare function sameBinding(a: SlotBinding | undefined, b: SlotBinding | undefined): boolean;
+export declare function nextSlotName(slots: Record<string, SlotDefinition>): string;
 export declare function migrateToSlots(def: DashboardDefinition): DashboardDefinition;
 export declare function bindWidgetSlot(def: DashboardDefinition, widgetId: string, binding: SlotBinding, measurements: string[], location?: LocationSelection): DashboardDefinition;
 export declare function clearWidgetDatasource(def: DashboardDefinition, widgetId: string): DashboardDefinition;

package/dist/synthetic.d.ts

@@ -1,10 +1,10 @@
+import type { HistoryWindow } from './history';
+import type { MemberSeed, MemberSeedPlan, MemberSink } from './members';
+import type { MeasurementBucket } from './queries';
 import type { AlarmStreamSink, AlarmSubscription, CommandDispatch, CommandStreamSink, CommandSubscription, LocationStreamSink, LocationSubscription, WidgetActions, WidgetDataSource, WidgetStreamSink } from './hub';
 import type { DatasourceSelector } from './types';
 export type SyntheticGenerator = 'sine' | 'ramp' | 'random-walk';
-export declare const SYNTHETIC_GENERATORS: ReadonlyArray<{
-    value: SyntheticGenerator;
-    label: string;
-}>;
+export declare const SYNTHETIC_GENERATORS: ReadonlyArray<SyntheticGenerator>;
 export interface SyntheticDataSourceConfig {
     generator?: SyntheticGenerator;
     intervalMs?: number;
@@ -31,6 +31,10 @@ export declare class SyntheticDataSource implements WidgetDataSource, WidgetActi
     acknowledgeAlarm(): Promise<void>;
     clearAlarm(): Promise<void>;
     sendCommand(): Promise<CommandDispatch>;
+    bucketMeasurements(datasource: DatasourceSelector, window: HistoryWindow): Promise<MeasurementBucket[]>;
+    private previewMembers;
+    subscribeMembers(datasource: DatasourceSelector, sink: MemberSink): () => void;
+    readMemberSeeds(deviceTokens: readonly string[], _plan: MemberSeedPlan, onSeed: (deviceToken: string, seed: MemberSeed | null) => void): Promise<void>;
     disposeAll(): void;
     private valueFor;
 }

package/dist/time-range.d.ts

@@ -0,0 +1,52 @@
+import type { DashboardDefinition } from './types';
+export declare const TIME_RANGE_PRESETS: readonly [{
+    readonly id: '15m';
+    readonly seconds: number;
+}, {
+    readonly id: '1h';
+    readonly seconds: number;
+}, {
+    readonly id: '6h';
+    readonly seconds: number;
+}, {
+    readonly id: '24h';
+    readonly seconds: number;
+}, {
+    readonly id: '7d';
+    readonly seconds: number;
+}];
+export type TimeRangePresetId = (typeof TIME_RANGE_PRESETS)[number]['id'];
+export declare const DEFAULT_TIME_RANGE_SECONDS: number;
+export declare const MIN_TIME_RANGE_SECONDS = 60;
+export declare const MAX_TIME_RANGE_SECONDS: number;
+export declare function isValidSpanSeconds(v: unknown): v is number;
+export interface TimeRangeState {
+    spanSeconds: number;
+    paused: boolean;
+    pausedAt?: number;
+}
+export declare function initialTimeRange(defaultSeconds: number | undefined, link?: {
+    spanSeconds?: number;
+    paused?: boolean;
+}, now?: number): TimeRangeState;
+export declare function pauseRange(state: TimeRangeState, now: number): TimeRangeState;
+export declare function resumeRange(state: TimeRangeState): TimeRangeState;
+export declare function withSpan(state: TimeRangeState, spanSeconds: number): TimeRangeState;
+export declare function rangeEnd(state: TimeRangeState, now: number): number;
+export interface RangeWindow {
+    startTime: string;
+    endTime: string;
+}
+export declare function rangeWindow(state: TimeRangeState, now: number): RangeWindow;
+export declare const MAX_SEED_BUCKETS = 240;
+export declare function bucketSecondsFor(spanSeconds: number): number;
+export declare function seedBucketCount(spanSeconds: number): number;
+export declare function parseRangeParam(value: string | null | undefined): number | undefined;
+export declare function parsePausedParam(value: string | null | undefined): boolean;
+export declare function timeRangeFromSearch(search: string): {
+    spanSeconds?: number;
+    paused?: boolean;
+};
+export declare function presetIdOf(spanSeconds: number): TimeRangePresetId | undefined;
+export declare function spanLabel(spanSeconds: number): string;
+export declare function setBoardTimeRange(def: DashboardDefinition, defaultSeconds: number | undefined): DashboardDefinition;

package/dist/types.d.ts

@@ -49,20 +49,77 @@ export interface UnboundSelector {
     location?: LocationSelection;
 }
 export type DatasourceSelector = DeviceSelector | AnchorSelector | DevicesSelector | RelatedTraversalSelector | SlotSelector | UnboundSelector;
-export declare const WIDGET_TYPES: readonly ['timeseries-chart', 'latest-card', 'gauge', 'table', 'label', 'image', 'alarm-table', 'alarm-count', 'command-button', 'entity-selector', 'map'];
+export declare const WIDGET_TYPES: readonly ['timeseries-chart', 'latest-card', 'gauge', 'table', 'label', 'image', 'alarm-table', 'alarm-count', 'command-button', 'entity-selector', 'map', 'linear-gauge', 'level-gauge', 'battery', 'status-light', 'signal-bars', 'compass', 'progress-ring', 'command-slider', 'command-toggle', 'stat-card', 'bar-chart', 'pie-chart', 'fleet-table'];
 export type WidgetType = (typeof WIDGET_TYPES)[number];
-export interface WidgetBox {
+export declare const PLACEMENT_ANCHORS: readonly ['top-left', 'top', 'top-right', 'left', 'center', 'right', 'bottom-left', 'bottom', 'bottom-right'];
+export type PlacementAnchor = (typeof PLACEMENT_ANCHORS)[number];
+export declare const PLACEMENT_MODES: readonly ['grid', 'relative'];
+export type PlacementMode = (typeof PLACEMENT_MODES)[number];
+export declare const RESERVED_PLACEMENT_MODES: readonly ['pinned', 'sticky'];
+export interface GridPlacement {
+    mode: 'grid';
     col: number;
-    colSpan: number;
     row: number;
-    rowSpan: number;
-    z: number;
+    cols: number;
+    rows: number;
+}
+export type RelativeSize = {
+    cols: number;
+    rows: number;
+} | {
+    fill: 'host';
+};
+export interface RelativePlacement {
+    mode: 'relative';
+    host: string;
+    anchor: PlacementAnchor;
+    self?: PlacementAnchor;
     offset?: {
         x: number;
         y: number;
     };
+    size: RelativeSize;
+    layer?: number;
+}
+export type Placement = GridPlacement | RelativePlacement;
+export type WidgetLayout = Record<string, Placement>;
+export declare const THEME_COLOR_TOKENS: readonly ['background', 'foreground', 'card', 'card-foreground', 'muted', 'muted-foreground', 'primary', 'primary-foreground', 'border', 'destructive', 'chart-1', 'chart-2', 'chart-3', 'chart-4', 'chart-5', 'sev-critical', 'sev-major', 'sev-minor', 'sev-warning'];
+export type ThemeColorToken = (typeof THEME_COLOR_TOKENS)[number];
+export declare const SPACE_TOKEN_PX: {
+    readonly 'space-0': 0;
+    readonly 'space-1': 4;
+    readonly 'space-2': 8;
+    readonly 'space-3': 12;
+    readonly 'space-4': 16;
+};
+export type SpaceTokenName = keyof typeof SPACE_TOKEN_PX;
+export declare const FRAME_VARIANTS: readonly ['card', 'flat', 'none'];
+export type FrameVariant = (typeof FRAME_VARIANTS)[number];
+export declare const FRAME_RADII: readonly ['none', 'sm', 'md', 'lg'];
+export type FrameRadius = (typeof FRAME_RADII)[number];
+export declare const FRAME_BORDER_WIDTHS: readonly [0, 1, 2, 3];
+export type FrameBorderWidth = (typeof FRAME_BORDER_WIDTHS)[number];
+export declare const FRAME_HEADERS: readonly ['auto', 'show', 'hide'];
+export type FrameHeader = (typeof FRAME_HEADERS)[number];
+export interface FrameBorder {
+    width?: FrameBorderWidth;
+    radius?: FrameRadius;
+    color?: ThemeColorToken;
+}
+export interface WidgetFrameSpec {
+    variant?: FrameVariant;
+    border?: FrameBorder;
+    padding?: SpaceTokenName;
+    background?: ThemeColorToken | 'transparent';
+    header?: FrameHeader;
+}
+export interface ResolvedFrame {
+    variant: FrameVariant;
+    border: Required<FrameBorder>;
+    padding: SpaceTokenName;
+    background: ThemeColorToken | 'transparent';
+    header: FrameHeader;
 }
-export type WidgetLayout = Record<string, WidgetBox>;
 export declare const UNKNOWN_WIDGET_TYPE = "unknown-widget";
 export type UnknownWidgetType = typeof UNKNOWN_WIDGET_TYPE;
 export interface WidgetImplementationRef {
@@ -78,6 +135,7 @@ export interface KnownWidgetInstance {
     layout: WidgetLayout;
     datasource?: DatasourceSelector;
     options?: Record<string, unknown>;
+    frame?: WidgetFrameSpec;
     raw?: undefined;
     reason?: undefined;
 }
@@ -88,6 +146,7 @@ export interface ExtensionWidgetInstance {
     layout: WidgetLayout;
     datasource?: DatasourceSelector;
     options?: Record<string, unknown>;
+    frame?: WidgetFrameSpec;
     raw?: undefined;
     reason?: undefined;
 }
@@ -105,6 +164,7 @@ export interface UnknownWidgetInstance {
     widget?: undefined;
     datasource?: undefined;
     options?: undefined;
+    frame?: undefined;
 }
 export type WidgetInstance = KnownWidgetInstance | ExtensionWidgetInstance | UnknownWidgetInstance;
 export type ResolvedWidgetInstance = KnownWidgetInstance | ExtensionWidgetInstance;
@@ -112,25 +172,43 @@ export interface CanvasBackground {
     color?: string | null;
     imageUrl?: string | null;
 }
+export type GridLength = number | SpaceTokenName;
 export interface CanvasGrid {
     columns: number;
-    gap: number | {
-        row: number;
-        col: number;
+    minCellSize: number;
+    gutter: GridLength | {
+        x: GridLength;
+        y: GridLength;
+    };
+    padding: GridLength | {
+        top: GridLength;
+        right: GridLength;
+        bottom: GridLength;
+        left: GridLength;
     };
-    rowHeight: number;
 }
 export type CanvasSizing = 'fill' | {
     width: number;
 } | {
     height: number;
 };
-export type Breakpoints = Record<string, number>;
+export type BreakpointSpec = number | {
+    minWidth: number;
+    columns: number;
+};
+export type Breakpoints = Record<string, BreakpointSpec>;
+export declare const CANVAS_DENSITIES: readonly ['compact', 'comfortable', 'wall'];
+export type CanvasDensity = (typeof CANVAS_DENSITIES)[number];
+export declare const DEFAULT_CANVAS_DENSITY: CanvasDensity;
+export declare const DENSITY_SCALE: Readonly<Record<CanvasDensity, number>>;
+export declare function isCanvasDensity(value: unknown): value is CanvasDensity;
 export interface Canvas {
     background?: CanvasBackground;
+    density?: CanvasDensity;
     grid: CanvasGrid;
     sizing: CanvasSizing;
     breakpoints: Breakpoints;
+    frame?: WidgetFrameSpec;
 }
 export type SlotBinding = {
     kind: 'device';
@@ -163,12 +241,19 @@ export interface SelectionTarget {
     slot: string;
     binding: SlotBinding;
 }
+export declare const CURRENT_SCHEMA_VERSION = 3;
+export interface BoardTimeRange {
+    defaultSeconds: number;
+}
 export interface DashboardDefinition {
     schemaVersion: number;
     title: string;
     canvas: Canvas;
     widgets: WidgetInstance[];
     slots?: Record<string, SlotDefinition>;
+    timeRange?: BoardTimeRange;
+    convertedFrom?: number;
+    convertedWindows?: string[];
 }
 export interface MeasurementSample {
     id: string;

package/dist/widget-descriptor.d.ts

@@ -1,8 +1,8 @@
-import type { AlarmStreamState, CommandStreamState, LocationStreamState, MeasurementStreamState } from './channel-snapshots';
+import type { AggregateStreamState, AlarmStreamState, CommandStreamState, LocationStreamState, MeasurementStreamState } from './channel-snapshots';
 import type { DefaultsOf, OptionConstraint, OptionKeysOfKind, WidgetOptionSpecs } from './option-schema';
 import { type WidgetType } from './types';
-export type WidgetChannel = 'measurement' | 'alarm' | 'control' | 'selection' | 'location' | 'none';
-export type ChannelSnapshot<C extends WidgetChannel> = C extends 'measurement' ? MeasurementStreamState : C extends 'alarm' ? AlarmStreamState : C extends 'control' ? CommandStreamState : C extends 'location' ? LocationStreamState : null;
+export type WidgetChannel = 'measurement' | 'alarm' | 'control' | 'selection' | 'location' | 'aggregate' | 'none';
+export type ChannelSnapshot<C extends WidgetChannel> = C extends 'measurement' ? MeasurementStreamState : C extends 'alarm' ? AlarmStreamState : C extends 'control' ? CommandStreamState : C extends 'location' ? LocationStreamState : C extends 'aggregate' ? AggregateStreamState : null;
 export type BuiltinWidgetId = WidgetType;
 export type NamespacedWidgetId = `${string}/${string}`;
 export type WidgetId = BuiltinWidgetId | NamespacedWidgetId;
@@ -41,8 +41,14 @@ export interface AckOptionRef<S extends WidgetOptionSpecs = WidgetOptionSpecs> {
     default?: 'true' | 'false';
 }
 type PageSize<S extends WidgetOptionSpecs> = ConstBinding<number> | NumberOptionRef<S>;
-export type ChannelBindingPolicy<C extends WidgetChannel, S extends WidgetOptionSpecs = WidgetOptionSpecs> = C extends 'measurement' ? {
+export type ChannelBindingPolicy<C extends WidgetChannel, S extends WidgetOptionSpecs = WidgetOptionSpecs> = C extends 'aggregate' ? {
+    windowSeconds?: NumberOptionRef<S>;
+} : C extends 'measurement' ? {
     window?: NumberOptionRef<S>;
+    windowSeconds?: NumberOptionRef<S>;
+    members?: ConstBinding<true> | (StringOptionRef<S> & {
+        equals: string;
+    });
 } : C extends 'alarm' ? {
     pageSize: PageSize<S>;
     state?: StringOptionRef<S>;
@@ -72,6 +78,19 @@ export interface WidgetDisplay {
     titleId?: string;
     categoryId?: string;
 }
+export interface WidgetSpan {
+    cols: number;
+    rows: number;
+}
+export type WidgetResizeMode = 'both' | 'horizontal' | 'vertical' | 'none';
+export interface WidgetLayoutSpec {
+    defaultSpan: WidgetSpan;
+    minSpan?: WidgetSpan;
+    maxSpan?: WidgetSpan;
+    resize?: WidgetResizeMode;
+}
+export declare function pinnedAxes(mode: WidgetResizeMode | undefined): readonly ('cols' | 'rows')[];
+export declare const FALLBACK_DEFAULT_SPAN: Readonly<WidgetSpan>;
 export declare const SDK_API_VERSION = 1;
 export interface WidgetDescriptor<C extends WidgetChannel = WidgetChannel, S extends WidgetOptionSpecs = WidgetOptionSpecs> {
     id: WidgetId;
@@ -86,6 +105,8 @@ export interface WidgetDescriptor<C extends WidgetChannel = WidgetChannel, S ext
     constraints?: readonly OptionConstraint<OptionKeysOfKind<S, 'number'>>[];
     defaults: DefaultsOf<S>;
     interactions: InteractionsFor<C>;
+    freshness?: true;
+    layout?: WidgetLayoutSpec;
 }
 export declare function defineWidgetDescriptor<const C extends WidgetChannel, const S extends WidgetOptionSpecs>(descriptor: WidgetDescriptor<C, S>): WidgetDescriptor<C, S>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devicechain/dashboards",
-  "version": "0.21.1",
+  "version": "0.22.0-rc.1",
   "description": "DeviceChain dashboard runtime — the DashboardHub (telemetry subscription multiplexing over the client wire, plus the alarm, command and location channels) and the dashboard-definition, selector, slot, and binding-manifest types.",
   "keywords": [
     "devicechain",
@@ -46,11 +46,11 @@
     "@graphql-typed-document-node/core": "^3.2.0"
   },
   "peerDependencies": {
-    "@devicechain/client": "0.21.1",
+    "@devicechain/client": "0.22.0-rc.1",
     "graphql": "^16.0.0 || ^17.0.0"
   },
   "devDependencies": {
-    "@devicechain/client": "0.21.1",
+    "@devicechain/client": "0.22.0-rc.1",
     "@types/node": "^26.6.5",
     "graphql": "^17.0.2",
     "typescript": "~7.0.2",