@openreachtech/furo-vue 1.3.1

package/types/generated/components/molecules/FuroTimeField/FuroTimeFieldContext.d.ts

@@ -0,0 +1,555 @@
+/**
+ * Furo-only parcel keys that are not forwarded to Reka `TimeFieldRoot`.
+ * These are stripped from the Reka v-bind spread.
+ */
+export const FURO_TIME_FIELD_PARCEL_KEYS: Set<string>;
+/**
+ * Context class for managing FuroTimeField atom.
+ *
+ * @extends {BaseFuroContext<null, Props, EmitEventName>}
+ */
+export default class FuroTimeFieldContext extends BaseFuroContext<null, Props, "CHANGE_VALUE" | "UPDATE_VALUE" | "COMMIT_VALUE"> {
+    /**
+     * Factory method.
+     *
+     * @template {X extends typeof FuroTimeFieldContext ? X : never} T, X
+     * @override
+     * @param {FuroTimeFieldContextFactoryParams} params - Parameters of this factory method.
+     * @returns {InstanceType<T>} An instance of this class.
+     * @this {T}
+     */
+    static override create<T extends X extends typeof FuroTimeFieldContext ? X : never, X>(this: T, { props, componentContext, refHash, }: FuroTimeFieldContextFactoryParams): InstanceType<T>;
+    /**
+     * Build ref hash.
+     *
+     * @override
+     * @returns {FuroTimeFieldContextParams['refHash']}
+     */
+    static override buildRefHash(): FuroTimeFieldContextParams["refHash"];
+    /**
+     * Build a zero `Time` (`00:00:00`) used as a fallback start for stepper edits.
+     *
+     * @returns {import('@internationalized/date').Time}
+     */
+    static buildZeroTime(): import("@internationalized/date").Time;
+    /**
+     * Get emit event names.
+     *
+     * @override
+     * @returns {Readonly<{
+     *   CHANGE_VALUE: 'change-value'
+     *   COMMIT_VALUE: 'commit-value'
+     *   UPDATE_VALUE: 'update:value'
+     * }>}
+     */
+    static override get EMIT_EVENT_NAME(): Readonly<{
+        CHANGE_VALUE: "change-value";
+        COMMIT_VALUE: "commit-value";
+        UPDATE_VALUE: "update:value";
+    }>;
+    /**
+     * Get emit event hash.
+     *
+     * @returns {{
+     *   'change-value': (payload: import('./TimeFieldEmitPayload.js').default) => void
+     *   'commit-value': (payload: import('./TimeFieldEmitPayload.js').default) => void
+     *   'update:value': (value: string | null) => void
+     * }}
+     */
+    static get EMIT_EVENT_HASH(): {
+        "change-value": (payload: import("./TimeFieldEmitPayload.js").default) => void;
+        "commit-value": (payload: import("./TimeFieldEmitPayload.js").default) => void;
+        "update:value": (value: string | null) => void;
+    };
+    /**
+     * Get the EmitPayload constructor.
+     *
+     * @returns {typeof TimeFieldEmitPayload}
+     */
+    static get EmitPayloadCtor(): typeof TimeFieldEmitPayload;
+    /**
+     * Map a time segment part (`hour` | `minute` | `second`) to the `Time.add` /
+     * `Time.subtract` duration unit key. Shared by focused-segment and granularity stepping.
+     *
+     * @returns {Readonly<{
+     *   hour: 'hours'
+     *   minute: 'minutes'
+     *   second: 'seconds'
+     * }>}
+     */
+    static get SEGMENT_UNIT_HASH(): Readonly<{
+        hour: "hours";
+        minute: "minutes";
+        second: "seconds";
+    }>;
+    /**
+     * Extract hour / minute / second string parts from a `Date` object in a specific IANA
+     * timezone via `Intl.DateTimeFormat`. Each part is zero-padded to 2 digits so the
+     * assembled `HH:MM:SS` string parses cleanly (generalizes the year-pad lesson).
+     *
+     * @param {{
+     *   raw: Date
+     *   timezone: string
+     * }} params - Parameters of this method.
+     * @returns {{ hour: string | null, minute: string | null, second: string | null }}
+     */
+    static extractTimePartsInTimezone({ raw, timezone, }: {
+        raw: Date;
+        timezone: string;
+    }): {
+        hour: string | null;
+        minute: string | null;
+        second: string | null;
+    };
+    /**
+     * Extract the DOM element that currently has focus, or `null` when the document is
+     * unavailable (e.g. SSR). Isolated as a static hook so tests can stub the active element.
+     *
+     * @returns {Element | null}
+     */
+    static extractActiveElement(): Element | null;
+    /**
+     * Find a single formatted time part by type and zero-pad it to 2 digits.
+     *
+     * @param {{
+     *   parts: Array<Intl.DateTimeFormatPart>
+     *   type: string
+     * }} params - Parameters of this method.
+     * @returns {string | null}
+     */
+    static extractPaddedTimePart({ parts, type, }: {
+        parts: Array<Intl.DateTimeFormatPart>;
+        type: string;
+    }): string | null;
+    /**
+     * Constructor.
+     *
+     * @param {FuroTimeFieldContextParams} params - Parameters of this constructor.
+     */
+    constructor({ props, componentContext, refHash, }: FuroTimeFieldContextParams);
+    refHash: {
+        rootElementRef: import("vue").Ref<HTMLElement | null>;
+        internalValueRef: import("vue").Ref<import("@internationalized/date").Time | null>;
+    };
+    /**
+     * Get the constructor of this class.
+     *
+     * @override
+     * @returns {typeof FuroTimeFieldContext}
+     */
+    override get Ctor(): typeof FuroTimeFieldContext;
+    /**
+     * Get root element ref.
+     *
+     * @returns {import('vue').Ref<HTMLElement | null>}
+     */
+    get rootElementRef(): import("vue").Ref<HTMLElement | null>;
+    /**
+     * Get internal Time value ref.
+     *
+     * @returns {import('vue').Ref<import('@internationalized/date').Time | null>}
+     */
+    get internalValueRef(): import("vue").Ref<import("@internationalized/date").Time | null>;
+    /**
+     * Whether the time field is in an externally-flagged invalid state.
+     *
+     * @returns {boolean}
+     */
+    get isInvalid(): boolean;
+    /**
+     * Whether the time field is disabled.
+     *
+     * @returns {boolean}
+     */
+    isDisabled(): boolean;
+    /**
+     * Whether the time field is read-only.
+     *
+     * @returns {boolean}
+     */
+    isReadonly(): boolean;
+    /**
+     * Placeholder text.
+     *
+     * @returns {string}
+     */
+    get placeholder(): string;
+    /**
+     * Time format (12 or 24). `null` when unset (locale default applies).
+     *
+     * @returns {number | null}
+     */
+    get timeFormat(): number | null;
+    /**
+     * Segment granularity (`hour` | `minute` | `second`). `null` when unset (Reka defaults to `minute`).
+     *
+     * @returns {string | null}
+     */
+    get granularity(): string | null;
+    /**
+     * IANA timezone identifier for `Date` object normalization (e.g. `'Asia/Tokyo'`).
+     * When `null`, normalization falls back to local time parts (timezone-naive).
+     * Furo-only — never forwarded to Reka.
+     *
+     * @returns {string | null}
+     */
+    get timezone(): string | null;
+    /**
+     * Accessible name of the decrement button.
+     *
+     * @returns {string}
+     */
+    get decrementLabel(): string;
+    /**
+     * Accessible name of the increment button.
+     *
+     * @returns {string}
+     */
+    get incrementLabel(): string;
+    /**
+     * Whether the increment button can step the value up.
+     * `false` when disabled/readonly, or when the next step would exceed `maxValue`.
+     * When no value has been entered yet, returns `true` — the first press seeds a
+     * starting value (see `extractIncrementSeed()`).
+     *
+     * @returns {boolean}
+     */
+    canIncrement(): boolean;
+    /**
+     * Whether the decrement button can step the value down.
+     * `false` when disabled/readonly, or when the previous step would fall below `minValue`.
+     * When no value has been entered yet, returns `true` — the first press seeds a
+     * starting value (see `extractDecrementSeed()`).
+     *
+     * @returns {boolean}
+     */
+    canDecrement(): boolean;
+    /**
+     * Setup component — sync external value into internal Time ref.
+     *
+     * @template {X extends FuroTimeFieldContext ? X : never} T, X
+     * @override
+     * @returns {T} - For method chaining.
+     * @this {T}
+     */
+    override setupComponent<T extends X extends FuroTimeFieldContext ? X : never, X>(this: T): T;
+    /**
+     * Normalize an external value to `Time | null`.
+     * Accepts `HH:MM` / `HH:MM:SS` strings, `Date` objects, `Time` instances, or `null`.
+     *
+     * @param {{
+     *   raw: string | Date | import('reka-ui').TimeValue | null
+     * }} params - Parameters of this method.
+     * @returns {import('@internationalized/date').Time | null}
+     */
+    normalizeToTime({ raw, }: {
+        raw: string | Date | import("reka-ui").TimeValue | null;
+    }): import("@internationalized/date").Time | null;
+    /**
+     * Parse an `HH:MM` or `HH:MM:SS` string into a `Time`.
+     *
+     * @param {{
+     *   raw: string
+     * }} params - Parameters of this method.
+     * @returns {import('@internationalized/date').Time | null}
+     */
+    normalizeStringToTime({ raw, }: {
+        raw: string;
+    }): import("@internationalized/date").Time | null;
+    /**
+     * Convert a `Date` object to `Time`.
+     * When `parcel.timezone` is set, time parts are extracted in that IANA timezone.
+     * Otherwise falls back to local wall-clock parts (timezone-naive).
+     *
+     * @param {{
+     *   raw: Date
+     * }} params - Parameters of this method.
+     * @returns {import('@internationalized/date').Time | null}
+     */
+    normalizeDateToTime({ raw, }: {
+        raw: Date;
+    }): import("@internationalized/date").Time | null;
+    /**
+     * Convert a `Date` object to `Time` using a specific IANA timezone.
+     * Returns `null` when the timezone identifier is invalid.
+     *
+     * @param {{
+     *   raw: Date
+     *   timezone: string
+     * }} params - Parameters of this method.
+     * @returns {import('@internationalized/date').Time | null}
+     */
+    normalizeDateToTimeInTimezone({ raw, timezone, }: {
+        raw: Date;
+        timezone: string;
+    }): import("@internationalized/date").Time | null;
+    /**
+     * Normalize a `Time` to an `HH:MM:SS` string or `null`.
+     * Always serializes via `time.toString()` (zero-pads), never manual segment assembly.
+     *
+     * @param {{
+     *   time: import('@internationalized/date').Time | null
+     * }} params - Parameters of this method.
+     * @returns {string | null}
+     */
+    normalizeToIsoString({ time, }: {
+        time: import("@internationalized/date").Time | null;
+    }): string | null;
+    /**
+     * Normalize the parcel `minValue` to a `Time`.
+     *
+     * @returns {import('@internationalized/date').Time | null}
+     */
+    normalizeMinValue(): import("@internationalized/date").Time | null;
+    /**
+     * Normalize the parcel `maxValue` to a `Time`.
+     *
+     * @returns {import('@internationalized/date').Time | null}
+     */
+    normalizeMaxValue(): import("@internationalized/date").Time | null;
+    /**
+     * Normalize the parcel `step` amount applied to the smallest visible segment (per
+     * `granularity`) for the increment/decrement buttons. A non-positive or non-numeric
+     * step falls back to `1`.
+     *
+     * @returns {number}
+     */
+    normalizeStep(): number;
+    /**
+     * Extract attributes for Reka `TimeFieldRoot`.
+     * Strips all Furo-only keys and re-applies normalized Reka props.
+     *
+     * @returns {Record<string, unknown>}
+     */
+    extractRootAttributes(): Record<string, unknown>;
+    /**
+     * Build the optional Reka root attributes that are only included when present.
+     *
+     * @returns {Record<string, unknown>}
+     */
+    buildOptionalRootAttributes(): Record<string, unknown>;
+    /**
+     * Strip Furo-only parcel keys from the parcel object.
+     *
+     * @returns {Record<string, unknown>}
+     */
+    stripFuroParcelKeys(): Record<string, unknown>;
+    /**
+     * Build a custom event for the emit payload.
+     *
+     * @param {{
+     *   name: string
+     *   value: string | null
+     * }} params - Parameters of this method.
+     * @returns {CustomEvent<{
+     *   target: HTMLElement | null
+     *   value: string | null
+     * }>}
+     */
+    buildCustomEvent({ name, value, }: {
+        name: string;
+        value: string | null;
+    }): CustomEvent<{
+        target: HTMLElement | null;
+        value: string | null;
+    }>;
+    /**
+     * Respond to `update:modelValue` from Reka `TimeFieldRoot`.
+     * Emits `change-value`, `update:value`, and `commit-value`.
+     *
+     * @param {{
+     *   time?: import('reka-ui').TimeValue | null
+     * }} params - Parameters of this method.
+     */
+    onChangeValue({ time, }: {
+        time?: import("reka-ui").TimeValue | null;
+    }): void;
+    /**
+     * Step the value up by `step` of the smallest visible segment, clamped to
+     * `[minValue, maxValue]`, then route through the same emit path as segment edits.
+     * When no value has been entered yet, the first press seeds the increment start
+     * value (`minValue ?? 00:00`) instead of stepping.
+     */
+    onIncrementValue(): void;
+    /**
+     * Handle a forward step that wrapped past midnight (`23:58 + 5 → 00:03`).
+     * Pins to `maxValue` when set; otherwise loops the wrapped value around (cyclic,
+     * since the field is unbounded above).
+     *
+     * @param {{
+     *   next: import('@internationalized/date').Time
+     * }} params - Parameters of this method.
+     */
+    onIncrementWrap({ next, }: {
+        next: import("@internationalized/date").Time;
+    }): void;
+    /**
+     * Step the value down by `step` of the smallest visible segment, clamped to
+     * `[minValue, maxValue]`, then route through the same emit path as segment edits.
+     * When no value has been entered yet, the first press seeds the decrement start
+     * value (`maxValue ?? 00:00`) instead of stepping.
+     */
+    onDecrementValue(): void;
+    /**
+     * Handle a backward step that wrapped past midnight (`00:02 - 5 → 23:57`).
+     * Pins to `minValue` when set; otherwise loops the wrapped value around (cyclic,
+     * since the field is unbounded below).
+     *
+     * @param {{
+     *   next: import('@internationalized/date').Time
+     * }} params - Parameters of this method.
+     */
+    onDecrementWrap({ next, }: {
+        next: import("@internationalized/date").Time;
+    }): void;
+    /**
+     * Build the starting value for the first increment press on an empty field.
+     * Begins at `minValue` when set, otherwise `00:00`, clamped into `[minValue, maxValue]`.
+     *
+     * @returns {import('@internationalized/date').Time}
+     */
+    extractIncrementSeed(): import("@internationalized/date").Time;
+    /**
+     * Build the starting value for the first decrement press on an empty field.
+     * Begins at `maxValue` when set, otherwise the end of the day (per `granularity`,
+     * e.g. `23:59`) so subsequent decrements keep stepping down instead of landing on
+     * `00:00` where they cannot cross midnight. Clamped into `[minValue, maxValue]`.
+     *
+     * @returns {import('@internationalized/date').Time}
+     */
+    extractDecrementSeed(): import("@internationalized/date").Time;
+    /**
+     * Build the end-of-day `Time` for the current `granularity`: `23:00` for hours,
+     * `23:59:59` for seconds, otherwise `23:59`. Used as the unbounded decrement seed.
+     *
+     * @returns {import('@internationalized/date').Time}
+     */
+    buildEndOfDayTime(): import("@internationalized/date").Time;
+    /**
+     * Build the duration object passed to `Time.add` / `Time.subtract` for one stepper press.
+     * The unit prioritizes the currently focused segment (`hour` / `minute` / `second`); when no
+     * segment is focused it falls back to `granularity` (the smallest visible segment), defaulting
+     * to minutes. The amount is always `step`.
+     *
+     * @returns {{
+     *   hours?: number
+     *   minutes?: number
+     *   seconds?: number
+     * }}
+     */
+    extractStepDuration(): {
+        hours?: number;
+        minutes?: number;
+        seconds?: number;
+    };
+    /**
+     * Map the currently focused time segment to a duration unit key, or `null` when no
+     * steppable segment (`hour` / `minute` / `second`) is focused.
+     *
+     * @returns {'hours' | 'minutes' | 'seconds' | null}
+     */
+    extractFocusedSegmentUnit(): "hours" | "minutes" | "seconds" | null;
+    /**
+     * Map the `granularity` (smallest visible segment) to a duration unit key.
+     * Defaults to minutes when granularity is unset or unrecognized.
+     *
+     * @returns {'hours' | 'minutes' | 'seconds'}
+     */
+    extractGranularityUnit(): "hours" | "minutes" | "seconds";
+    /**
+     * Extract the currently focused time segment part (`hour` | `minute` | `second` | `dayPeriod`)
+     * from the active element, or `null` when no time segment is focused. Reads the
+     * `data-reka-time-field-segment` attribute the underlying primitive stamps on each segment.
+     *
+     * @returns {string | null}
+     */
+    extractFocusedSegmentPart(): string | null;
+    /**
+     * Clamp a `Time` into the `[minValue, maxValue]` window.
+     * Returns the bound when out of range, otherwise the original time.
+     *
+     * @param {{
+     *   time: import('@internationalized/date').Time
+     * }} params - Parameters of this method.
+     * @returns {import('@internationalized/date').Time}
+     */
+    clampTime({ time, }: {
+        time: import("@internationalized/date").Time;
+    }): import("@internationalized/date").Time;
+    /**
+     * Whether the segment part is a literal separator (e.g. `:` between segments).
+     *
+     * @param {{ part: import('reka-ui').SegmentPart }} params - Parameters of this method.
+     * @returns {boolean}
+     */
+    isLiteralPart({ part, }: {
+        part: import("reka-ui").SegmentPart;
+    }): boolean;
+    /**
+     * Format a time segment value for display. Hour, minute, and second segments are zero-padded
+     * to two digits (e.g. `9` → `09`) so the field width stays constant as the value changes;
+     * the day period (AM/PM) and literals pass through unchanged. The underlying primitive
+     * renders filled segments with single-digit (`numeric`) formatting, so this — together with
+     * `tabular-nums` — keeps the trigger from resizing and shifting the popover.
+     *
+     * @param {{
+     *   part: import('reka-ui').SegmentPart
+     *   value: string
+     * }} params - Parameters of this method.
+     * @returns {string}
+     */
+    formatSegmentValue({ part, value, }: {
+        part: import("reka-ui").SegmentPart;
+        value: string;
+    }): string;
+    /**
+     * Whether a segment part should display zero-padded to two digits (hour, minute, second).
+     *
+     * @param {{ part: import('reka-ui').SegmentPart }} params - Parameters of this method.
+     * @returns {boolean}
+     */
+    isTwoDigitSegmentPart({ part, }: {
+        part: import("reka-ui").SegmentPart;
+    }): boolean;
+}
+export type FuroTimeFieldContextParams = import("../../../contexts/BaseFuroContext.js").BaseFuroContextParams & {
+    props: Props;
+    componentContext: ComponentContext;
+    refHash: {
+        rootElementRef: import("vue").Ref<HTMLElement | null>;
+        internalValueRef: import("vue").Ref<import("@internationalized/date").Time | null>;
+    };
+};
+export type FuroTimeFieldContextFactoryParams = Omit<FuroTimeFieldContextParams, "refHash"> & {
+    refHash?: {
+        rootElementRef: import("vue").Ref<HTMLElement | null>;
+        internalValueRef: import("vue").Ref<import("@internationalized/date").Time | null>;
+    };
+};
+export type EmitEventName = keyof typeof FuroTimeFieldContext.EMIT_EVENT_NAME;
+export type Props = import("vue").HTMLAttributes & {
+    parcel?: TimeFieldParcel | null;
+};
+export type TimeFieldParcel = Record<string, unknown> & {
+    value?: string | null;
+    invalid?: boolean;
+    placeholder?: string | null;
+    disabled?: boolean;
+    readonly?: boolean;
+    minValue?: string | null;
+    maxValue?: string | null;
+    timeFormat?: number | null;
+    granularity?: "hour" | "minute" | "second" | null;
+    step?: number | null;
+    stepSnapping?: boolean | null;
+    timezone?: string | null;
+    decrementLabel?: string;
+    incrementLabel?: string;
+};
+export type ComponentContext = import("vue").SetupContext<FuroTimeFieldEmitHash>;
+export type FuroTimeFieldEmitHash = typeof FuroTimeFieldContext.EMIT_EVENT_HASH;
+export type FuroTimeFieldSetup = (props: Props, componentContext: ComponentContext) => {
+    context: FuroTimeFieldContext;
+};
+import BaseFuroContext from '../../../contexts/BaseFuroContext.js';
+import TimeFieldEmitPayload from './TimeFieldEmitPayload.js';

package/types/generated/components/molecules/FuroTimeField/TimeFieldEmitPayload.d.ts

@@ -0,0 +1,41 @@
+/**
+ * TimeFieldEmitPayload.
+ *
+ * @extends {BaseEmitPayload<TimeFieldRawEvent, HTMLElement>}
+ */
+export default class TimeFieldEmitPayload extends BaseEmitPayload<TimeFieldRawEvent, HTMLElement> {
+    constructor({ rawEvent, }: import("../../../emit-payload/BaseEmitPayload.js").BaseEmitPayloadParams<TimeFieldRawEvent>);
+    /**
+     * Get the event detail.
+     *
+     * @returns {TimeFieldRawEvent['detail'] | null}
+     */
+    get eventDetail(): TimeFieldRawEvent["detail"] | null;
+    /**
+     * Selected time as `HH:MM:SS` string, or `null` when cleared.
+     *
+     * @returns {string | null}
+     */
+    get value(): string | null;
+    /**
+     * Whether the payload carries an empty (null) value.
+     *
+     * @returns {boolean}
+     */
+    hasEmptyValue(): boolean;
+    /**
+     * Whether the payload carries a non-null time value.
+     *
+     * @returns {boolean}
+     */
+    hasValue(): boolean;
+}
+export type TimeFieldRawEvent = CustomEvent<{
+    target: HTMLElement | null;
+    value: string | null;
+}>;
+export type TimeFieldEmitPayloadParams = {
+    rawEvent: TimeFieldRawEvent;
+};
+export type TimeFieldEmitPayloadFactoryParams = TimeFieldEmitPayloadParams;
+import BaseEmitPayload from '../../../emit-payload/BaseEmitPayload.js';

package/types/generated/components/molecules/FuroToggleGroup/FuroToggleGroup.vue.d.ts

@@ -0,0 +1,70 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    parcel?: import("./FuroToggleGroupContext.js").FuroToggleGroupParcel | null;
+}, {
+    context: FuroToggleGroupContext;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'change-value': (payload: import("./ToggleGroupEmitPayload.js").default) => void;
+    'update:value': (value: FuroToggleGroupValue) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    parcel?: import("./FuroToggleGroupContext.js").FuroToggleGroupParcel | null;
+}> & Readonly<{
+    "onChange-value"?: (payload: import("./ToggleGroupEmitPayload.js").default) => any;
+    "onUpdate:value"?: (value: import("./FuroToggleGroupContext.js").FuroToggleGroupValue) => any;
+}>, {
+    parcel: import("./FuroToggleGroupContext.js").FuroToggleGroupParcel;
+}, {}, {
+    ToggleGroupRoot: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("reka-ui").ToggleGroupRootProps<import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]>> & Readonly<{
+            "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any;
+        }, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("reka-ui").ToggleGroupRootProps<import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]>> & Readonly<{
+            "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any) | undefined;
+        }>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ToggleGroupRootProps<import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]>> & Readonly<{
+        "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any;
+    }, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {
+                modelValue: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[] | undefined;
+            }) => any;
+        };
+    });
+    ToggleGroupOption: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("reka-ui").ToggleGroupItemProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("reka-ui").ToggleGroupItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("reka-ui").ToggleGroupItemProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {
+                modelValue: boolean;
+                state: "off" | "on";
+                pressed: boolean;
+                disabled: boolean;
+            }) => any;
+        };
+    });
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+import FuroToggleGroupContext from './FuroToggleGroupContext.js';