@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/webrtc-diagnostics/session-run.d.ts

@@ -1,125 +1,138 @@
-import { WebrtcSessionDebug } from '@camstack/types';
-import { StreamDebugSample, WebrtcDebugStats } from '../stream-debug/webrtc-debug-stats';
-import { HubCandidateSummary, IceCandidateType, ParsedIceCandidate } from './ice-candidates';
-import { DiagnosticIcePolicy, SessionVerdict } from './session-verdict';
+/**
+* One hub session run, as an immutable event log folded into a report.
+*
+* The run drives the real `CameraStreamPlayer`; this module never touches a
+* peer connection. The host feeds it what it observed — the hub's answer SDP
+* and trickled candidates (from the wrapped signaling callbacks), the
+* browser's own candidates and ICE / DTLS / peer transitions (from the
+* player's peer connection), the first decoded frame, and the player's 1 Hz
+* `StreamDebugSample` (the `webrtc-debug-stats` collector plus the server's
+* `getSessionDebug` answer). `at` is milliseconds since the run started.
+*
+* Every number in the report is `null` until something measured it (D393).
+*/
+import type { WebrtcSessionDebug } from "@camstack/types";
+import type { StreamDebugSample, WebrtcDebugStats } from "../stream-debug/webrtc-debug-stats";
+import { type HubCandidateSummary, type IceCandidateType, type ParsedIceCandidate } from "./ice-candidates";
+import { type DiagnosticIcePolicy, type SessionVerdict } from "./session-verdict";
 export type SessionRunEvent = {
-    readonly kind: 'offer-answered';
-    readonly at: number;
-    readonly sessionId: string;
-    readonly sdpAnswer: string;
+	readonly kind: "offer-answered";
+	readonly at: number;
+	readonly sessionId: string;
+	readonly sdpAnswer: string;
 } | {
-    readonly kind: 'hub-candidates';
-    readonly at: number;
-    readonly candidates: readonly string[];
-    readonly done: boolean;
+	readonly kind: "hub-candidates";
+	readonly at: number;
+	readonly candidates: readonly string[];
+	readonly done: boolean;
 } | {
-    readonly kind: 'local-candidate';
-    readonly at: number;
-    readonly candidate: string;
-    readonly url: string | null;
-    readonly relayProtocol: string | null;
+	readonly kind: "local-candidate";
+	readonly at: number;
+	readonly candidate: string;
+	readonly url: string | null;
+	readonly relayProtocol: string | null;
 } | {
-    readonly kind: 'ice-state';
-    readonly at: number;
-    readonly state: string;
+	readonly kind: "ice-state";
+	readonly at: number;
+	readonly state: string;
 } | {
-    readonly kind: 'dtls-state';
-    readonly at: number;
-    readonly state: string;
+	readonly kind: "dtls-state";
+	readonly at: number;
+	readonly state: string;
 } | {
-    readonly kind: 'peer-state';
-    readonly at: number;
-    readonly state: string;
+	readonly kind: "peer-state";
+	readonly at: number;
+	readonly state: string;
 } | {
-    readonly kind: 'first-frame';
-    readonly at: number;
+	readonly kind: "first-frame";
+	readonly at: number;
 } | {
-    readonly kind: 'sample';
-    readonly at: number;
-    readonly sample: StreamDebugSample;
+	readonly kind: "sample";
+	readonly at: number;
+	readonly sample: StreamDebugSample;
 } | {
-    readonly kind: 'reconnect';
-    readonly at: number;
+	readonly kind: "reconnect";
+	readonly at: number;
 } | {
-    readonly kind: 'error';
-    readonly at: number;
-    readonly message: string;
+	readonly kind: "error";
+	readonly at: number;
+	readonly message: string;
 };
 export interface StateMark {
-    readonly state: string;
-    readonly at: number;
+	readonly state: string;
+	readonly at: number;
 }
 export interface LocalCandidateRecord {
-    readonly candidate: ParsedIceCandidate;
-    readonly url: string | null;
-    readonly relayProtocol: string | null;
+	readonly candidate: ParsedIceCandidate;
+	readonly url: string | null;
+	readonly relayProtocol: string | null;
 }
 export interface SessionRunState {
-    readonly policy: DiagnosticIcePolicy;
-    readonly sessionIds: readonly string[];
-    readonly sdpAnswer: string | null;
-    readonly trickled: readonly string[];
-    readonly trickleDone: boolean | null;
-    readonly local: readonly LocalCandidateRecord[];
-    readonly ice: readonly StateMark[];
-    readonly dtls: readonly StateMark[];
-    readonly peer: readonly StateMark[];
-    readonly firstFrameAt: number | null;
-    /** The last sample that carried client stats — a later failed poll keeps it. */
-    readonly lastStats: WebrtcDebugStats | null;
-    readonly lastServer: WebrtcSessionDebug | null;
-    readonly maxServerPacketsSent: number | null;
-    readonly lastServerError: string | null;
-    readonly samples: number;
-    readonly reconnects: number;
-    readonly errors: readonly string[];
+	readonly policy: DiagnosticIcePolicy;
+	readonly sessionIds: readonly string[];
+	readonly sdpAnswer: string | null;
+	readonly trickled: readonly string[];
+	readonly trickleDone: boolean | null;
+	readonly local: readonly LocalCandidateRecord[];
+	readonly ice: readonly StateMark[];
+	readonly dtls: readonly StateMark[];
+	readonly peer: readonly StateMark[];
+	readonly firstFrameAt: number | null;
+	/** The last sample that carried client stats — a later failed poll keeps it. */
+	readonly lastStats: WebrtcDebugStats | null;
+	readonly lastServer: WebrtcSessionDebug | null;
+	readonly maxServerPacketsSent: number | null;
+	readonly lastServerError: string | null;
+	readonly samples: number;
+	readonly reconnects: number;
+	readonly errors: readonly string[];
 }
 export declare function emptySessionRun(policy: DiagnosticIcePolicy): SessionRunState;
 export declare function reduceSessionRun(state: SessionRunState, event: SessionRunEvent): SessionRunState;
 export interface SessionTimeline {
-    readonly iceConnectedMs: number | null;
-    readonly dtlsConnectedMs: number | null;
-    readonly firstFrameMs: number | null;
-    readonly iceFinalState: string | null;
-    readonly dtlsFinalState: string | null;
+	readonly iceConnectedMs: number | null;
+	readonly dtlsConnectedMs: number | null;
+	readonly firstFrameMs: number | null;
+	readonly iceFinalState: string | null;
+	readonly dtlsFinalState: string | null;
 }
 export interface SessionPath {
-    /** `local/remote` candidate types of the selected pair, e.g. `relay/host`. */
-    readonly pairType: string | null;
-    readonly protocol: string | null;
-    readonly rttMs: number | null;
+	/** `local/remote` candidate types of the selected pair, e.g. `relay/host`. */
+	readonly pairType: string | null;
+	readonly protocol: string | null;
+	readonly rttMs: number | null;
 }
 export interface SessionMedia {
-    readonly clientBytesReceived: number | null;
-    readonly clientPacketsReceived: number | null;
-    readonly framesDecoded: number | null;
-    readonly serverPacketsSent: number | null;
-    readonly serverAlive: boolean | null;
-    readonly servedTier: string | null;
-    readonly egressLeg: string | null;
-    readonly lossPercent: number | null;
-    readonly freezeCount: number | null;
-    readonly totalFreezeMs: number | null;
-    readonly pliCount: number | null;
-    readonly nackCount: number | null;
+	readonly clientBytesReceived: number | null;
+	readonly clientPacketsReceived: number | null;
+	readonly framesDecoded: number | null;
+	readonly serverPacketsSent: number | null;
+	readonly serverAlive: boolean | null;
+	readonly servedTier: string | null;
+	readonly egressLeg: string | null;
+	readonly lossPercent: number | null;
+	readonly freezeCount: number | null;
+	readonly totalFreezeMs: number | null;
+	readonly pliCount: number | null;
+	readonly nackCount: number | null;
 }
 export interface SessionLocalCandidates {
-    readonly countByType: Readonly<Record<IceCandidateType, number>>;
-    readonly relayProtocols: readonly string[];
-    readonly urls: readonly string[];
+	readonly countByType: Readonly<Record<IceCandidateType, number>>;
+	readonly relayProtocols: readonly string[];
+	readonly urls: readonly string[];
 }
 export interface HubSessionRunReport {
-    readonly policy: DiagnosticIcePolicy;
-    readonly durationMs: number;
-    readonly sessionIds: readonly string[];
-    readonly hub: HubCandidateSummary;
-    readonly local: SessionLocalCandidates;
-    readonly timeline: SessionTimeline;
-    readonly path: SessionPath;
-    readonly media: SessionMedia;
-    readonly reconnects: number;
-    readonly errors: readonly string[];
-    readonly serverError: string | null;
-    readonly verdict: SessionVerdict;
+	readonly policy: DiagnosticIcePolicy;
+	readonly durationMs: number;
+	readonly sessionIds: readonly string[];
+	readonly hub: HubCandidateSummary;
+	readonly local: SessionLocalCandidates;
+	readonly timeline: SessionTimeline;
+	readonly path: SessionPath;
+	readonly media: SessionMedia;
+	readonly reconnects: number;
+	readonly errors: readonly string[];
+	readonly serverError: string | null;
+	readonly verdict: SessionVerdict;
 }
 export declare function finalizeSessionRun(state: SessionRunState, durationMs: number): HubSessionRunReport;

package/dist/composites/webrtc-diagnostics/session-verdict.d.ts

@@ -1,28 +1,37 @@
-import { HubReachabilityFlag } from './ice-candidates';
-export type SessionVerdictLayer = 'transport' | 'hub-dtls' | 'media-black-hole' | 'hub-not-sending' | 'loss-keyframe' | 'healthy' | 'unknown';
+/**
+* Per-layer verdict for one hub session run.
+*
+* The layers are checked in the order media actually climbs them, and the
+* first one that did not hold is the verdict:
+*   ICE (a candidate pair) → DTLS (the keys) → RTP (bytes arrive) → decode.
+* A layer whose deciding number was not measured makes the verdict `unknown`
+* — a guessed verdict is the thing an operator trusts and stops measuring.
+*/
+import type { HubReachabilityFlag } from "./ice-candidates";
+export type SessionVerdictLayer = "transport" | "hub-dtls" | "media-black-hole" | "hub-not-sending" | "loss-keyframe" | "healthy" | "unknown";
 export interface SessionVerdict {
-    readonly layer: SessionVerdictLayer;
-    readonly title: string;
-    readonly detail: string;
+	readonly layer: SessionVerdictLayer;
+	readonly title: string;
+	readonly detail: string;
 }
-export type DiagnosticIcePolicy = 'all' | 'relay';
+export type DiagnosticIcePolicy = "all" | "relay";
 export interface VerdictInput {
-    readonly policy: DiagnosticIcePolicy;
-    readonly durationMs: number;
-    readonly iceConnected: boolean;
-    readonly iceFinalState: string | null;
-    readonly dtlsConnected: boolean;
-    readonly dtlsFinalState: string | null;
-    readonly hubFlag: HubReachabilityFlag;
-    readonly clientPacketsReceived: number | null;
-    readonly framesDecoded: number | null;
-    readonly serverPacketsSent: number | null;
-    readonly pliCount: number | null;
-    readonly freezeCount: number | null;
-    readonly lossPercent: number | null;
+	readonly policy: DiagnosticIcePolicy;
+	readonly durationMs: number;
+	readonly iceConnected: boolean;
+	readonly iceFinalState: string | null;
+	readonly dtlsConnected: boolean;
+	readonly dtlsFinalState: string | null;
+	readonly hubFlag: HubReachabilityFlag;
+	readonly clientPacketsReceived: number | null;
+	readonly framesDecoded: number | null;
+	readonly serverPacketsSent: number | null;
+	readonly pliCount: number | null;
+	readonly freezeCount: number | null;
+	readonly lossPercent: number | null;
 }
 /** PLIs the browser may send in one run before it counts as a storm: one at
- *  start-up plus one recovery is normal; three means keyframes keep breaking. */
+*  start-up plus one recovery is normal; three means keyframes keep breaking. */
 export declare const PLI_STORM_COUNT = 3;
 /** Packet loss over the run above which a freeze is attributed to loss. */
 export declare const LOSS_PERCENT_HIGH = 2;

package/dist/composites/widget-panel.d.ts

@@ -1,28 +1,28 @@
-import { ReactNode } from 'react';
+import { type ReactNode, type JSX } from "react";
 interface WidgetPanelProps {
-    /** Header title — rendered uppercase, letter-spaced, foreground. */
-    readonly title: string;
-    /** Optional leading icon node (size it `h-3.5 w-3.5` for alignment). */
-    readonly icon?: ReactNode;
-    /** Optional right-aligned header slot (timestamp, live badge, …). Ignored
-     *  when `collapsible` is set — the chevron takes that slot. */
-    readonly headerRight?: ReactNode;
-    /** Render the header as a toggle that shows/hides the body. */
-    readonly collapsible?: boolean;
-    /** Initial open state for a collapsible panel (default open). */
-    readonly defaultOpen?: boolean;
-    /** Body padding/utility override (default `p-3`). */
-    readonly bodyClassName?: string;
-    readonly children: ReactNode;
+	/** Header title — rendered uppercase, letter-spaced, foreground. */
+	readonly title: string;
+	/** Optional leading icon node (size it `h-3.5 w-3.5` for alignment). */
+	readonly icon?: ReactNode;
+	/** Optional right-aligned header slot (timestamp, live badge, …). Ignored
+	*  when `collapsible` is set — the chevron takes that slot. */
+	readonly headerRight?: ReactNode;
+	/** Render the header as a toggle that shows/hides the body. */
+	readonly collapsible?: boolean;
+	/** Initial open state for a collapsible panel (default open). */
+	readonly defaultOpen?: boolean;
+	/** Body padding/utility override (default `p-3`). */
+	readonly bodyClassName?: string;
+	readonly children: ReactNode;
 }
-export declare function WidgetPanel({ title, icon, headerRight, collapsible, defaultOpen, bodyClassName, children, }: WidgetPanelProps): import("react").JSX.Element;
+export declare function WidgetPanel({ title, icon, headerRight, collapsible, defaultOpen, bodyClassName, children }: WidgetPanelProps): JSX.Element;
 interface WidgetMetricCardProps {
-    readonly label: string;
-    readonly icon?: ReactNode;
-    /** The metric value (text or node). */
-    readonly children: ReactNode;
-    /** Optional sub-line under the value (e.g. "3 segment ranges"). */
-    readonly footer?: ReactNode;
+	readonly label: string;
+	readonly icon?: ReactNode;
+	/** The metric value (text or node). */
+	readonly children: ReactNode;
+	/** Optional sub-line under the value (e.g. "3 segment ranges"). */
+	readonly footer?: ReactNode;
 }
-export declare function WidgetMetricCard({ label, icon, children, footer }: WidgetMetricCardProps): import("react").JSX.Element;
+export declare function WidgetMetricCard({ label, icon, children, footer }: WidgetMetricCardProps): JSX.Element;
 export {};

package/dist/composites/widget-slot.d.ts

@@ -1,20 +1,38 @@
-import { ReactNode } from 'react';
-import { WidgetProps } from '../contexts/widget-registry.js';
+/**
+* <WidgetSlot> — single host-side mount point for any addon-contributed
+* widget. Consumers reference a widget by its public id
+* (`<addonId>/<stableId>`), the slot looks the widget's metadata up in
+* the shared `WidgetRegistry`, resolves the component through the
+* unified `useRemoteComponent` Module-Federation loader (the SAME path
+* `ContributionRenderer`'s `kind:'remote'` branch uses), validates host
+* context against the widget's `requires` metadata, and renders one of:
+*   - skeleton placeholder while the bundle is still loading,
+*   - inline error fallback when the widget id is unknown OR the host
+*     didn't supply a required context (`deviceContext` /
+*     `integrationContext`),
+*   - the resolved component otherwise.
+*
+* The slot is intentionally STUPID — no styling beyond the skeleton/
+* error fallback. Layout (card vs inline, sizing) is the host's
+* responsibility.
+*/
+import { type ReactNode } from "react";
+import { type WidgetProps } from "../contexts/widget-registry.js";
 export interface WidgetSlotProps {
-    /** `<addonId>/<stableId>` — the public widget identifier. */
-    readonly widgetId: string;
-    /** Host context — picked up by metadata `requires` validation. Defaults to `'device-tab'`. */
-    readonly host?: WidgetProps['host'];
-    /** Forwarded to widget. */
-    readonly config?: Readonly<Record<string, unknown>>;
-    /** Forwarded to widget. */
-    readonly deviceId?: number;
-    readonly integrationId?: string;
-    /** Stable instance id — defaults to `widgetId` for non-dashboard hosts (single mount per page). */
-    readonly instanceId?: string;
-    /** Dashboard sizing — placeholder for v1. */
-    readonly size?: WidgetProps['size'];
-    readonly columns?: number;
-    readonly rows?: number;
+	/** `<addonId>/<stableId>` — the public widget identifier. */
+	readonly widgetId: string;
+	/** Host context — picked up by metadata `requires` validation. Defaults to `'device-tab'`. */
+	readonly host?: WidgetProps["host"];
+	/** Forwarded to widget. */
+	readonly config?: Readonly<Record<string, unknown>>;
+	/** Forwarded to widget. */
+	readonly deviceId?: number;
+	readonly integrationId?: string;
+	/** Stable instance id — defaults to `widgetId` for non-dashboard hosts (single mount per page). */
+	readonly instanceId?: string;
+	/** Dashboard sizing — placeholder for v1. */
+	readonly size?: WidgetProps["size"];
+	readonly columns?: number;
+	readonly rows?: number;
 }
 export declare function WidgetSlot(props: WidgetSlotProps): ReactNode;

package/dist/contexts/custom-field-renderers.d.ts

@@ -1,26 +1,62 @@
-import { ComponentType, ReactNode } from 'react';
-import { ConfigField } from '@camstack/types';
 /**
- * Props shape every custom renderer receives. Keep it congruent with
- * the built-in `case` branches so the dispatcher in `config-form-field`
- * can pass arguments uniformly.
- */
+* Custom field renderer registry.
+*
+* The ui-library's `config-form-field.tsx` switch handles built-in field
+* types (text, number, select, …). Field types declared in
+* `@camstack/types/interfaces/config-ui` that need heavy host-app
+* components (e.g. `zone-editor` → polygon canvas via konva) are
+* dispatched through this registry: a host app (admin-ui) wraps the
+* device-detail tree with `CustomFieldRenderersProvider`, supplying a
+* map of `field.type → React component`. The form renderer looks up
+* the type at the `default:` branch and renders the registered
+* component instead of returning `null`.
+*
+* Why a registry instead of static imports:
+*   1. ui-library stays free of heavy deps (konva, etc.) — host apps
+*      that don't render the device page never pay the cost.
+*   2. New custom field types can be added by addon code without
+*      modifying ui-library.
+*   3. The renderer can read host-only context (e.g. tRPC client,
+*      device id) directly, instead of threading props through the
+*      form's recursion.
+*
+* Usage (host app, e.g. admin-ui App.tsx):
+*
+*   <CustomFieldRenderersProvider renderers={{
+*     'zone-editor': (props) => <DeviceZonesPanel field={props.field} />,
+*   }}>
+*     <Routes>...</Routes>
+*   </CustomFieldRenderersProvider>
+*
+* The renderer receives the same props shape as built-in cases:
+*   - `field`: the discriminated-union ConfigField (already narrowed by
+*     the renderer's contract — but TypeScript can't see through the
+*     dynamic dispatch, so the implementation must validate / cast).
+*   - `value`, `onChange`, `disabled` — same as built-in fields.
+*/
+import { type ComponentType, type ReactNode, type JSX } from "react";
+import type { ConfigField } from "@camstack/types";
+/**
+* Props shape every custom renderer receives. Keep it congruent with
+* the built-in `case` branches so the dispatcher in `config-form-field`
+* can pass arguments uniformly.
+*/
 export interface CustomFieldRendererProps {
-    readonly field: ConfigField;
-    readonly value: unknown;
-    readonly onChange: (value: unknown) => void;
-    readonly disabled?: boolean;
+	readonly field: ConfigField;
+	readonly value: unknown;
+	readonly onChange: (value: unknown) => void;
+	readonly disabled?: boolean;
 }
 export type CustomFieldRenderer = ComponentType<CustomFieldRendererProps>;
 export type CustomFieldRendererMap = Readonly<Record<string, CustomFieldRenderer>>;
 export interface CustomFieldRenderersProviderProps {
-    readonly renderers: CustomFieldRendererMap;
-    readonly children: ReactNode;
+	readonly renderers: CustomFieldRendererMap;
+	readonly children: ReactNode;
 }
-export declare function CustomFieldRenderersProvider({ renderers, children, }: CustomFieldRenderersProviderProps): import("react").JSX.Element;
+export declare function CustomFieldRenderersProvider({ renderers, children }: CustomFieldRenderersProviderProps): JSX.Element;
 /**
- * Look up a registered renderer by `field.type`. Returns null when no
- * renderer is registered — caller falls back to its built-in handling
- * (or renders nothing).
- */
+* Look up a registered renderer by `field.type`. Returns null when no
+* renderer is registered — caller falls back to its built-in handling
+* (or renders nothing).
+*/
 export declare function useCustomFieldRenderer(type: string): CustomFieldRenderer | null;

package/dist/contexts/device-context.d.ts

@@ -1,19 +1,39 @@
-import { ReactNode } from 'react';
 /**
- * Cached device snapshot. Loose-typed (`Record<string, unknown>`) at
- * the boundary because the wire shape lives in different places
- * depending on the caller — DeviceDetail reads from
- * `deviceManager.list`, `addon-admin-ui` from a hand-loaded subset.
- * Renderers narrow the fields they actually need.
- */
+* DeviceContext — current device id (and optional cached device
+* snapshot) for the page subtree.
+*
+* Provided by host pages (admin-ui DeviceDetail, addon device pages)
+* so that deeply-nested form/field renderers can resolve the device
+* they're acting on without prop drilling. Used by custom field
+* renderers (`zone-editor` → polygon canvas, `device-info` /
+* `live-stream-viewer` / `pipeline-stats` / `doorbell-recent` /
+* `stream-network-stats` → overview blocks) that need to call
+* device-scoped caps or read the device's static metadata.
+*
+* The `device` snapshot is optional — when the host has already
+* fetched the device (DeviceDetail loads it on mount) the renderer
+* can read static fields (name, type, addonId, features, stableId)
+* directly from context instead of round-tripping `deviceManager.get`.
+* Adapters that need it MUST also tolerate `null` so they can be
+* mounted in subtrees that don't carry the snapshot — they fall back
+* to their own query in that case.
+*/
+import { type ReactNode, type JSX } from "react";
+/**
+* Cached device snapshot. Loose-typed (`Record<string, unknown>`) at
+* the boundary because the wire shape lives in different places
+* depending on the caller — DeviceDetail reads from
+* `deviceManager.list`, `addon-admin-ui` from a hand-loaded subset.
+* Renderers narrow the fields they actually need.
+*/
 export type DeviceSnapshot = Readonly<Record<string, unknown>>;
 export interface DeviceContextProviderProps {
-    readonly deviceId: number;
-    /** Optional cached device snapshot — readers narrow the fields they need. */
-    readonly device?: DeviceSnapshot;
-    readonly children: ReactNode;
+	readonly deviceId: number;
+	/** Optional cached device snapshot — readers narrow the fields they need. */
+	readonly device?: DeviceSnapshot;
+	readonly children: ReactNode;
 }
-export declare function DeviceContextProvider({ deviceId, device, children }: DeviceContextProviderProps): import("react").JSX.Element;
+export declare function DeviceContextProvider({ deviceId, device, children }: DeviceContextProviderProps): JSX.Element;
 /** @returns the device id of the current page subtree, or null if outside any provider. */
 export declare function useDeviceId(): number | null;
 /** @returns the cached device snapshot, or null when no snapshot is provided. */

package/dist/contexts/device-quick-detail.d.ts

@@ -1,9 +1,18 @@
-import { ReactNode } from 'react';
+/**
+* Optional host-provided "open quick detail for this device id" callback.
+*
+* The devices table (`DeviceItem` / `DeviceList`) draws a discreet quick-
+* detail glyph whenever a host has published a handler — admin-ui mounts
+* ONE provider at the app shell with the modal. Call sites never wire the
+* button themselves; absence of a provider means no glyph (unit tests,
+* embeds that do not host the modal).
+*/
+import { type ReactNode } from "react";
 export type DeviceQuickDetailOpen = (deviceId: number) => void;
 export interface DeviceQuickDetailProviderProps {
-    readonly open: DeviceQuickDetailOpen;
-    readonly children: ReactNode;
+	readonly open: DeviceQuickDetailOpen;
+	readonly children: ReactNode;
 }
-export declare function DeviceQuickDetailProvider({ open, children, }: DeviceQuickDetailProviderProps): ReactNode;
+export declare function DeviceQuickDetailProvider({ open, children }: DeviceQuickDetailProviderProps): ReactNode;
 /** The host's open callback, or null when no provider is mounted. */
 export declare function useDeviceQuickDetailOpen(): DeviceQuickDetailOpen | null;