@camstack/ui-library 1.2.256 → 1.2.258

package/dist/composites/clips/clip-tile-media.d.ts

@@ -1,45 +1,77 @@
-import { Clip } from '@camstack/types';
+/**
+* What a clip tile SHOWS — and why, when it shows nothing.
+*
+* Three mutually exclusive shapes arrive on a `Clip` (D549 decision 5):
+*
+*  - `thumbnail` — VOUCHED. A JPEG is already on disk. Stamping this from a
+*    URL template once pointed 35 % of one camera's tiles at a 404, which is
+*    why it now means "confirmed", not "probably".
+*  - `thumbnailMint` — an OFFER. A route that MAY produce a still, asked only
+*    for rows actually on screen. It answers 200 with the image, or **204**
+*    with a refusal.
+*  - `thumbnailUnavailable.reason` — the provider already knows no mint can
+*    succeed now, so the tile draws the reason instead of firing a request.
+*
+* A clip that carries NONE of the three is its own case and says so. Falling
+* through to an empty grey box is the "we did not look" ambiguity the whole
+* vouching rule exists to remove, and a box is indistinguishable from a
+* loading one.
+*
+* ## "Not yet" and "never" are two answers (D563)
+*
+* The 204 carries a CODE (`x-camstack-reason-code`), the camera's own PROSE
+* (`x-camstack-reason`) and a DISPOSITION (`x-camstack-disposition`). Only the
+* disposition decides whether the tile comes back — this file does not
+* classify codes, because a client that pattern-matches a server's words
+* drifts the first time a word changes, and it already had: the route sends
+* `queue-full: 16 thumbnail mints already waiting for host …` while the table
+* below was keyed by the bare token, so on the live hub EVERY refusal rendered
+* as `Refused: <prose>` — measured on 592, 43 of the 60 tiles of one page.
+*
+* A missing or unrecognised disposition is FINAL. That is not a guess, it is
+* the old behaviour: an addon built before D563 sends no such header and its
+* tiles latch exactly as they used to, instead of gaining a retry loop nobody
+* tested against that build.
+*/
+import type { Clip } from "@camstack/types";
 /** The five things a tile can be. */
 export type ClipTileMedia = {
-    readonly kind: 'vouched';
-    readonly url: string;
+	readonly kind: "vouched";
+	readonly url: string;
 } | {
-    readonly kind: 'mint';
-    readonly url: string;
-}
-/** The still is QUEUED. The tile shows loading and comes back, under a
- *  bound — `text` is what it says if the bound runs out. */
- | {
-    readonly kind: 'deferred';
-    readonly reason: string;
-    readonly text: string;
-    readonly retryAfterMs: number | null;
+	readonly kind: "mint";
+	readonly url: string;
+} | {
+	readonly kind: "deferred";
+	readonly reason: string;
+	readonly text: string;
+	readonly retryAfterMs: number | null;
 } | {
-    readonly kind: 'unavailable';
-    readonly reason: string;
-    readonly text: string;
+	readonly kind: "unavailable";
+	readonly reason: string;
+	readonly text: string;
 } | {
-    readonly kind: 'none';
-    readonly text: string;
+	readonly kind: "none";
+	readonly text: string;
 };
 /** A 204, as its three headers arrived. `undefined` where a header was absent
- *  — which is a real case, not a defect: an addon older than D563 sends only
- *  the prose. */
+*  — which is a real case, not a defect: an addon older than D563 sends only
+*  the prose. */
 export interface MintRefusalHeaders {
-    readonly code: string | undefined;
-    readonly reason: string;
-    readonly disposition: string | undefined;
-    readonly retryAfterMs?: number | null;
+	readonly code: string | undefined;
+	readonly reason: string;
+	readonly disposition: string | undefined;
+	readonly retryAfterMs?: number | null;
 }
 /** What to draw for one clip's tile. */
 export declare function resolveTileMedia(clip: Clip): ClipTileMedia;
 /**
- * A 204, as something the tile can draw.
- *
- * `deferred` is the ONLY answer that comes back, and only because the server
- * said so. Everything else — an unknown disposition, an absent one, a code
- * this build has never heard of — is final, so the failure mode of a
- * vocabulary that moves is a tile that stops early, never one that asks for
- * ever.
- */
+* A 204, as something the tile can draw.
+*
+* `deferred` is the ONLY answer that comes back, and only because the server
+* said so. Everything else — an unknown disposition, an absent one, a code
+* this build has never heard of — is final, so the failure mode of a
+* vocabulary that moves is a tile that stops early, never one that asks for
+* ever.
+*/
 export declare function describeRefusal(headers: MintRefusalHeaders): ClipTileMedia;

package/dist/composites/clips/clip-view-state.d.ts

@@ -1,56 +1,86 @@
-import { Clip, ClipSource } from '@camstack/types';
-import { ClipBand, ClipBandPlan } from './clip-band.js';
-import { ClipSourceNotice } from './clip-source-state.js';
+/**
+* The clips browser's on-screen state, decided once, in one place.
+*
+* Four states have to be TELLABLE APART on screen, and that is the whole point
+* of the external-videoclips line (D549 § 7b):
+*
+*  - `loading` — never rendered as empty. A list drawn while a query is still
+*    pending is a claim the data does not support.
+*  - `empty` — a band with no rows, carrying the BAND and the sources that
+*    answered for it. "No clips" with neither of those is the lie this whole
+*    surface exists to stop telling.
+*  - `refused` — the selected band is wider than the bound `clip-band.ts`
+*    sets, so nothing was asked. Added with the timebar (D564): a band can be
+*    made arbitrarily wide and a day could not, and a range that answered
+*    partly would read as the whole of it.
+*  - `listed` — rows, plus every source that could NOT contribute, named with
+*    its reason verbatim. One unreachable source never empties the others
+*    (the dispatcher's rule 2), and the operator must see both halves: today
+*    a hub child lists `onboard` and shows `native:reolink:hub` unreachable.
+*  - `failed` — the read itself failed. Not an answer, so not "empty" either.
+*
+* There is no client-side source filter here, and that is a decision, not an
+* omission. `listClips` is asked of ONE provider at a time, and NAMING it is
+* required (`provider`, D554 amended) — the operator settled it on 2026-09-20,
+* *"l'utilizzatore è uno solo"* [there is only one user] — so what arrives is already the answer for
+* the provider on screen and there is nothing to filter out of it. What
+* survives unchanged is the rule the old filter existed to protect: every
+* source a camera HAS is still described here, with its availability,
+* whichever provider was asked.
+*/
+import type { Clip, ClipSource } from "@camstack/types";
+import type { ClipBand, ClipBandPlan } from "./clip-band.js";
+import { type ClipSourceNotice } from "./clip-source-state.js";
 /** React Query's settled-ness, narrowed to what this decision needs. */
-export type ClipQueryStatus = 'pending' | 'error' | 'success';
+export type ClipQueryStatus = "pending" | "error" | "success";
 export interface ClipsViewInput {
-    /**
-     * The period the list is about, and whether it may be asked for at all
-     * (`clip-band.ts`). A refused plan means NO query was fired, which is why
-     * the refusal has to be decided here rather than inferred from a query that
-     * will stay `pending` for ever.
-     */
-    readonly plan: ClipBandPlan;
-    /**
-     * The provider the clip list was asked of, or `null` when the camera lists
-     * NO source to ask.
-     *
-     * Naming one is required (D554 amended), so "nobody to ask" is a real state and it
-     * has to be told apart from "not answered yet": the query never fires, its
-     * status stays `pending` for ever, and a surface that only consults the
-     * status spins against a question with no addressee. Exactly the trap
-     * `too-wide` has, arriving from the other end.
-     */
-    readonly provider: string | null;
-    readonly clipsStatus: ClipQueryStatus;
-    readonly clips: readonly Clip[];
-    readonly sourcesStatus: ClipQueryStatus;
-    readonly sources: readonly ClipSource[];
-    readonly clipsError?: string;
-    readonly sourcesError?: string;
+	/**
+	* The period the list is about, and whether it may be asked for at all
+	* (`clip-band.ts`). A refused plan means NO query was fired, which is why
+	* the refusal has to be decided here rather than inferred from a query that
+	* will stay `pending` for ever.
+	*/
+	readonly plan: ClipBandPlan;
+	/**
+	* The provider the clip list was asked of, or `null` when the camera lists
+	* NO source to ask.
+	*
+	* Naming one is required (D554 amended), so "nobody to ask" is a real state and it
+	* has to be told apart from "not answered yet": the query never fires, its
+	* status stays `pending` for ever, and a surface that only consults the
+	* status spins against a question with no addressee. Exactly the trap
+	* `too-wide` has, arriving from the other end.
+	*/
+	readonly provider: string | null;
+	readonly clipsStatus: ClipQueryStatus;
+	readonly clips: readonly Clip[];
+	readonly sourcesStatus: ClipQueryStatus;
+	readonly sources: readonly ClipSource[];
+	readonly clipsError?: string;
+	readonly sourcesError?: string;
 }
 export type ClipsViewState = {
-    readonly kind: 'loading';
+	readonly kind: "loading";
 } | {
-    readonly kind: 'failed';
-    readonly message: string;
+	readonly kind: "failed";
+	readonly message: string;
 } | {
-    /** The band is wider than the bound, so nothing was asked. */
-    readonly kind: 'refused';
-    readonly band: ClipBand;
-    readonly localDays: number;
-    readonly maxLocalDays: number;
+	/** The band is wider than the bound, so nothing was asked. */
+	readonly kind: "refused";
+	readonly band: ClipBand;
+	readonly localDays: number;
+	readonly maxLocalDays: number;
 } | {
-    readonly kind: 'empty';
-    readonly band: ClipBand;
-    readonly answered: readonly ClipSourceNotice[];
-    readonly silent: readonly ClipSourceNotice[];
-    /** No source could answer at all — a different fact from a quiet day. */
-    readonly nobodyAnswered: boolean;
+	readonly kind: "empty";
+	readonly band: ClipBand;
+	readonly answered: readonly ClipSourceNotice[];
+	readonly silent: readonly ClipSourceNotice[];
+	/** No source could answer at all — a different fact from a quiet day. */
+	readonly nobodyAnswered: boolean;
 } | {
-    readonly kind: 'listed';
-    readonly clips: readonly Clip[];
-    readonly answered: readonly ClipSourceNotice[];
-    readonly silent: readonly ClipSourceNotice[];
+	readonly kind: "listed";
+	readonly clips: readonly Clip[];
+	readonly answered: readonly ClipSourceNotice[];
+	readonly silent: readonly ClipSourceNotice[];
 };
 export declare function resolveClipsView(input: ClipsViewInput): ClipsViewState;

package/dist/composites/code-block.d.ts

@@ -1,6 +1,7 @@
+import { type JSX } from "react";
 export interface CodeBlockProps {
-    children: string;
-    maxHeight?: number;
-    className?: string;
+	children: string;
+	maxHeight?: number;
+	className?: string;
 }
-export declare function CodeBlock({ children, maxHeight, className }: CodeBlockProps): import("react").JSX.Element;
+export declare function CodeBlock({ children, maxHeight, className }: CodeBlockProps): JSX.Element;

package/dist/composites/config-form-builder.d.ts

@@ -1,18 +1,19 @@
-import { ConfigUISchema, FieldProbeResult } from '@camstack/types';
-import { ProbeState } from './config-form-field';
+import { type JSX } from "react";
+import type { ConfigUISchema, FieldProbeResult } from "@camstack/types";
+import type { ProbeState } from "./config-form-field";
 export type TranslationFn = (key: string) => string;
 export declare function resolveLabel(value: string | undefined, t?: TranslationFn): string | undefined;
 interface FormBuilderProps {
-    schema: ConfigUISchema;
-    values: Record<string, unknown>;
-    onChange: (values: Record<string, unknown>) => void;
-    disabled?: boolean;
-    translationFn?: TranslationFn;
-    onTestField?: (key: string, value: unknown) => Promise<FieldProbeResult>;
-    /** External probe results from useProbeAll hook */
-    probeResults?: Record<string, ProbeState>;
-    /** Callback to clear a probe result when a field value changes */
-    onClearProbe?: (key: string) => void;
+	schema: ConfigUISchema;
+	values: Record<string, unknown>;
+	onChange: (values: Record<string, unknown>) => void;
+	disabled?: boolean;
+	translationFn?: TranslationFn;
+	onTestField?: (key: string, value: unknown) => Promise<FieldProbeResult>;
+	/** External probe results from useProbeAll hook */
+	probeResults?: Record<string, ProbeState>;
+	/** Callback to clear a probe result when a field value changes */
+	onClearProbe?: (key: string) => void;
 }
-export declare function ConfigFormBuilder({ schema, values, onChange, disabled, translationFn, onTestField, probeResults, onClearProbe, }: FormBuilderProps): import("react").JSX.Element;
+export declare function ConfigFormBuilder({ schema, values, onChange, disabled, translationFn, onTestField, probeResults, onClearProbe }: FormBuilderProps): JSX.Element;
 export {};

package/dist/composites/config-form-field.d.ts

@@ -1,70 +1,71 @@
-import { ConfigField, ConfigNodeSelectField, ConfigNodeMultiSelectField, FieldProbeResult } from '@camstack/types';
-import { TranslationFn } from './config-form-builder';
+import { type JSX } from "react";
+import type { ConfigField, ConfigNodeSelectField, ConfigNodeMultiSelectField, FieldProbeResult } from "@camstack/types";
+import type { TranslationFn } from "./config-form-builder";
 /** Probe state for a single field — exported for callers that need to track probe lifecycle externally. */
 export interface ProbeState {
-    status: 'probing' | 'ok' | 'error';
-    result?: FieldProbeResult;
+	status: "probing" | "ok" | "error";
+	result?: FieldProbeResult;
 }
 interface FormFieldProps {
-    field: ConfigField;
-    values: Record<string, unknown>;
-    onChange: (key: string, value: unknown) => void;
-    disabled?: boolean;
-    translationFn?: TranslationFn;
-    /**
-     * Dedicated probe callback — used by the device-creation dialog where
-     * the device doesn't exist yet so the generic `onAction` routing
-     * cannot resolve an addon owner. For existing-device forms prefer
-     * `onAction` with action `'test-probe'`: the probe field falls back
-     * to it when `onTestField` is absent, so the two paths converge.
-     */
-    onTestField?: (key: string, value: unknown) => Promise<FieldProbeResult>;
-    /** External probe result (from "Test All" button) */
-    externalProbe?: {
-        status: 'probing' | 'ok' | 'error';
-        result?: FieldProbeResult;
-    };
-    /**
-     * Inline-action callback. Fired by icon buttons on any field
-     * (copy-value, regenerate-rtsp-token, …) and by the probe field's
-     * Test button when `onTestField` is not provided — in that case the
-     * action name is `'test-probe'` and the current field value flows
-     * through the third arg so the handler can probe it.
-     *
-     * Returns `Promise<unknown>` (not `void`) because some actions yield
-     * a result the caller wants (the probe returns a `FieldProbeResult`).
-     */
-    onAction?: (action: string, key: string, value?: unknown) => Promise<unknown>;
-    /** All fields in the section — used to resolve defaults for showWhen conditions */
-    allFields?: readonly ConfigField[];
+	field: ConfigField;
+	values: Record<string, unknown>;
+	onChange: (key: string, value: unknown) => void;
+	disabled?: boolean;
+	translationFn?: TranslationFn;
+	/**
+	* Dedicated probe callback — used by the device-creation dialog where
+	* the device doesn't exist yet so the generic `onAction` routing
+	* cannot resolve an addon owner. For existing-device forms prefer
+	* `onAction` with action `'test-probe'`: the probe field falls back
+	* to it when `onTestField` is absent, so the two paths converge.
+	*/
+	onTestField?: (key: string, value: unknown) => Promise<FieldProbeResult>;
+	/** External probe result (from "Test All" button) */
+	externalProbe?: {
+		status: "probing" | "ok" | "error";
+		result?: FieldProbeResult;
+	};
+	/**
+	* Inline-action callback. Fired by icon buttons on any field
+	* (copy-value, regenerate-rtsp-token, …) and by the probe field's
+	* Test button when `onTestField` is not provided — in that case the
+	* action name is `'test-probe'` and the current field value flows
+	* through the third arg so the handler can probe it.
+	*
+	* Returns `Promise<unknown>` (not `void`) because some actions yield
+	* a result the caller wants (the probe returns a `FieldProbeResult`).
+	*/
+	onAction?: (action: string, key: string, value?: unknown) => Promise<unknown>;
+	/** All fields in the section — used to resolve defaults for showWhen conditions */
+	allFields?: readonly ConfigField[];
 }
-export declare function NodeSelectField({ field, value, onChange, disabled, translationFn, }: {
-    field: ConfigNodeSelectField;
-    value: unknown;
-    onChange: (v: unknown) => void;
-    disabled?: boolean;
-    translationFn?: TranslationFn;
-}): import("react").JSX.Element;
-export declare function NodeMultiSelectField({ field, value, onChange, disabled, translationFn, }: {
-    field: ConfigNodeMultiSelectField;
-    value: unknown;
-    onChange: (v: unknown) => void;
-    disabled?: boolean;
-    translationFn?: TranslationFn;
-}): import("react").JSX.Element;
+export declare function NodeSelectField({ field, value, onChange, disabled, translationFn }: {
+	field: ConfigNodeSelectField;
+	value: unknown;
+	onChange: (v: unknown) => void;
+	disabled?: boolean;
+	translationFn?: TranslationFn;
+}): JSX.Element | null;
+export declare function NodeMultiSelectField({ field, value, onChange, disabled, translationFn }: {
+	field: ConfigNodeMultiSelectField;
+	value: unknown;
+	onChange: (v: unknown) => void;
+	disabled?: boolean;
+	translationFn?: TranslationFn;
+}): JSX.Element | null;
 /**
- * Resolve a `ConfigCondition` against the form's flat values bag and the
- * sibling-field list (used to recover schema defaults when the
- * referenced field hasn't been touched yet). Returns `true` for fields
- * with no `showWhen` — i.e. always visible — and for fields whose
- * condition is missing a recognised operator (forward-compat: a future
- * operator added to `ConfigCondition` won't accidentally hide every
- * field on older clients).
- *
- * Exported so callers (FormBuilder section renderer, future
- * sub-tab visibility checks, …) can pre-evaluate which fields would be
- * rendered without instantiating a React subtree.
- */
+* Resolve a `ConfigCondition` against the form's flat values bag and the
+* sibling-field list (used to recover schema defaults when the
+* referenced field hasn't been touched yet). Returns `true` for fields
+* with no `showWhen` — i.e. always visible — and for fields whose
+* condition is missing a recognised operator (forward-compat: a future
+* operator added to `ConfigCondition` won't accidentally hide every
+* field on older clients).
+*
+* Exported so callers (FormBuilder section renderer, future
+* sub-tab visibility checks, …) can pre-evaluate which fields would be
+* rendered without instantiating a React subtree.
+*/
 export declare function isFieldVisible(field: ConfigField, values: Record<string, unknown>, allFields?: readonly ConfigField[]): boolean;
-export declare function FormField({ field, values, onChange, disabled, translationFn, onTestField, externalProbe, allFields, onAction, }: FormFieldProps): import("react").JSX.Element | null;
+export declare function FormField({ field, values, onChange, disabled, translationFn, onTestField, externalProbe, allFields, onAction }: FormFieldProps): JSX.Element | null;
 export { FormField as ConfigFormField };

package/dist/composites/config-icon-field.d.ts

@@ -1,11 +1,12 @@
+import { type JSX } from "react";
 export interface ConfigIconFieldControlProps {
-    /** The field's label — names the picker for assistive tech. */
-    readonly label: string;
-    /** The stored value (anything — only a vocabulary key is honoured). */
-    readonly value: unknown;
-    /** The field's default key; `''` when the schema declares none. */
-    readonly defaultKey: string;
-    readonly disabled?: boolean;
-    readonly onChange: (key: string) => void;
+	/** The field's label — names the picker for assistive tech. */
+	readonly label: string;
+	/** The stored value (anything — only a vocabulary key is honoured). */
+	readonly value: unknown;
+	/** The field's default key; `''` when the schema declares none. */
+	readonly defaultKey: string;
+	readonly disabled?: boolean;
+	readonly onChange: (key: string) => void;
 }
-export declare function ConfigIconFieldControl({ label, value, defaultKey, disabled, onChange, }: ConfigIconFieldControlProps): import("react").JSX.Element;
+export declare function ConfigIconFieldControl({ label, value, defaultKey, disabled, onChange }: ConfigIconFieldControlProps): JSX.Element;

package/dist/composites/config-secret-field.d.ts

@@ -1,41 +1,65 @@
-import { ConfigField, SecretFieldView } from '@camstack/types';
-import { ReactNode } from 'react';
+/**
+* A keychain-stored secret in a settings form (D787, D789) — drawn as ONE
+* password input with an eye.
+*
+* The form never holds the value. It receives the field's VIEW —
+* `{ $secret, v, set: true }` when something is stored, `null` when nothing
+* is — and sends back exactly one of three things:
+*
+*  - the view, unchanged ........ KEEP (an untouched field sends nothing, so
+*                                 the hydrated view stays the value; a revealed
+*                                 value left as it was sends the view again);
+*  - a non-empty typed string ... CHANGE (the owner stores it in the keychain);
+*  - `{ $secretClear: true }` ... CLEAR — only when the operator emptied a box
+*                                 that showed a value they revealed or typed.
+*
+* `''` is never sent for "remove": the save path reads it as KEEP, because an
+* empty string is what a defaults fallback writes back. An untouched field
+* looks empty (a masked placeholder) and so can never clear by accident.
+*
+* The eye on an untouched stored secret asks the host's audited
+* `keychain-admin.reveal` (provided with {@link SecretRevealProvider}) for the
+* value; a host that provides none, or a pre-keychain inline value (no ref),
+* cannot reveal — the eye then only shows what the operator types.
+*/
+import { type ConfigField, type SecretFieldView } from "@camstack/types";
+import { type ReactNode, type JSX } from "react";
 /** Returns the stored value of a ref (audited by the host). */
 export type SecretRevealFn = (ref: string) => Promise<string>;
 /** How long the System → Secrets page shows a revealed value. */
-export declare const SECRET_REVEAL_MS = 10000;
+export declare const SECRET_REVEAL_MS = 1e4;
 /** What an untouched stored secret shows in place of its value. */
-export declare const SECRET_MASK_PLACEHOLDER = "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
-export declare function SecretRevealProvider({ reveal, children, }: {
-    readonly reveal: SecretRevealFn;
-    readonly children: ReactNode;
-}): import("react").JSX.Element;
+export declare const SECRET_MASK_PLACEHOLDER = "••••••••";
+export declare function SecretRevealProvider({ reveal, children }: {
+	readonly reveal: SecretRevealFn;
+	readonly children: ReactNode;
+}): JSX.Element;
 /** Does this value belong to the keychain rendering (a view, or "not set")? */
 export declare function isKeychainFieldValue(value: unknown): boolean;
 /**
- * What the operator has done to the field. `untouched` shows nothing and
- * sends nothing; `visible` holds text the operator can see — revealed (then
- * `revealed` is the stored value) or typed.
- */
+* What the operator has done to the field. `untouched` shows nothing and
+* sends nothing; `visible` holds text the operator can see — revealed (then
+* `revealed` is the stored value) or typed.
+*/
 export type SecretEntry = {
-    readonly kind: 'untouched';
+	readonly kind: "untouched";
 } | {
-    readonly kind: 'visible';
-    readonly text: string;
-    readonly revealed: string | null;
+	readonly kind: "visible";
+	readonly text: string;
+	readonly revealed: string | null;
 };
 /**
- * The value the form sends for an entry. `stored` — something is stored (or
- * already marked for removal) — is what makes an emptied box a CLEAR.
- */
+* The value the form sends for an entry. `stored` — something is stored (or
+* already marked for removal) — is what makes an emptied box a CLEAR.
+*/
 export declare function secretSubmitValue(entry: SecretEntry, original: SecretFieldView | null, stored: boolean): unknown;
 export interface SecretFieldProps {
-    readonly field: ConfigField;
-    /** The view (or null) the form was hydrated with, or what the operator has done since. */
-    readonly value: unknown;
-    readonly onChange: (value: unknown) => void;
-    readonly disabled?: boolean;
-    /** Multi-line entry (a PEM key). */
-    readonly multiline?: boolean;
+	readonly field: ConfigField;
+	/** The view (or null) the form was hydrated with, or what the operator has done since. */
+	readonly value: unknown;
+	readonly onChange: (value: unknown) => void;
+	readonly disabled?: boolean;
+	/** Multi-line entry (a PEM key). */
+	readonly multiline?: boolean;
 }
-export declare function SecretFieldControl({ field, value, onChange, disabled, multiline, }: SecretFieldProps): import("react").JSX.Element;
+export declare function SecretFieldControl({ field, value, onChange, disabled, multiline }: SecretFieldProps): JSX.Element;

package/dist/composites/confirm-action-button.d.ts

@@ -1,41 +1,54 @@
-import { ReactNode, ComponentType } from 'react';
-import { ButtonProps } from '../primitives/button';
+/**
+* ConfirmActionButton — destructive-action button with a modal confirm.
+*
+* Two-step UX for any operation operators shouldn't trigger by accident:
+* reboot device, restart addon, regenerate token, etc. The trigger is a
+* normal Button that opens a Dialog; confirming runs the async action,
+* the trigger spinner-disables itself for the duration, and the dialog
+* closes on success. Errors surface inline at the dialog's bottom.
+*
+* Generic on `TResult` so callers don't have to discard the return
+* value. Pass an `icon` to render it inside the trigger (e.g. RotateCw
+* for reboot, RefreshCw for restart).
+*/
+import { type ReactNode, type ComponentType, type JSX } from "react";
+import { type ButtonProps } from "../primitives/button";
 export interface ConfirmActionButtonProps<TResult> {
-    /** Visible label on the trigger button. */
-    readonly label: string;
-    /** Icon component (lucide-react) rendered inside the trigger. */
-    readonly icon?: ComponentType<{
-        className?: string;
-    }>;
-    /** Dialog title. Defaults to "Confirm action". */
-    readonly title?: string;
-    /**
-     * Dialog body — accepts either a string (rendered as DialogDescription)
-     * or arbitrary ReactNode for callers that need lists, code blocks, etc.
-     */
-    readonly description?: ReactNode;
-    /** Label on the confirm button inside the dialog. Defaults to `label`. */
-    readonly confirmLabel?: string;
-    /** Visual variant for the trigger button (defaults to `outline`). */
-    readonly triggerVariant?: ButtonProps['variant'];
-    /**
-     * Visual variant for the confirm button inside the dialog. Defaults to
-     * `danger` since this component is meant for destructive actions.
-     */
-    readonly confirmVariant?: ButtonProps['variant'];
-    /** Trigger button size — propagated to the underlying Button. */
-    readonly size?: ButtonProps['size'];
-    /** Disable the trigger entirely (gates rendering instead of UX state). */
-    readonly disabled?: boolean;
-    /** Optional extra class name on the trigger. */
-    readonly className?: string;
-    /**
-     * The async action to run on confirm. Must throw on failure so this
-     * component can surface the error inline. The result is returned to
-     * `onSuccess` for callers that need it (e.g. to invalidate queries).
-     */
-    readonly action: () => Promise<TResult>;
-    /** Called after `action` resolves, with the result. */
-    readonly onSuccess?: (result: TResult) => void;
+	/** Visible label on the trigger button. */
+	readonly label: string;
+	/** Icon component (lucide-react) rendered inside the trigger. */
+	readonly icon?: ComponentType<{
+		className?: string;
+	}>;
+	/** Dialog title. Defaults to "Confirm action". */
+	readonly title?: string;
+	/**
+	* Dialog body — accepts either a string (rendered as DialogDescription)
+	* or arbitrary ReactNode for callers that need lists, code blocks, etc.
+	*/
+	readonly description?: ReactNode;
+	/** Label on the confirm button inside the dialog. Defaults to `label`. */
+	readonly confirmLabel?: string;
+	/** Visual variant for the trigger button (defaults to `outline`). */
+	readonly triggerVariant?: ButtonProps["variant"];
+	/**
+	* Visual variant for the confirm button inside the dialog. Defaults to
+	* `danger` since this component is meant for destructive actions.
+	*/
+	readonly confirmVariant?: ButtonProps["variant"];
+	/** Trigger button size — propagated to the underlying Button. */
+	readonly size?: ButtonProps["size"];
+	/** Disable the trigger entirely (gates rendering instead of UX state). */
+	readonly disabled?: boolean;
+	/** Optional extra class name on the trigger. */
+	readonly className?: string;
+	/**
+	* The async action to run on confirm. Must throw on failure so this
+	* component can surface the error inline. The result is returned to
+	* `onSuccess` for callers that need it (e.g. to invalidate queries).
+	*/
+	readonly action: () => Promise<TResult>;
+	/** Called after `action` resolves, with the result. */
+	readonly onSuccess?: (result: TResult) => void;
 }
-export declare function ConfirmActionButton<TResult>({ label, icon: Icon, title, description, confirmLabel, triggerVariant, confirmVariant, size, disabled, className, action, onSuccess, }: ConfirmActionButtonProps<TResult>): import("react").JSX.Element;
+export declare function ConfirmActionButton<TResult>({ label, icon: Icon, title, description, confirmLabel, triggerVariant, confirmVariant, size, disabled, className, action, onSuccess }: ConfirmActionButtonProps<TResult>): JSX.Element;