origam 2.2.1 → 2.5.0

package/dist/src/interfaces/Media/media-player.interface.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/interfaces/Media/media-player.interface.d.ts

@@ -0,0 +1,121 @@
+import type { Ref } from 'vue';
+/**
+ * Reactive state surface returned by `useMediaPlayer` — the
+ * media-agnostic base shared between `useVideoPlayer` and
+ * `useAudioPlayer`. Fields below describe state that applies to both
+ * `HTMLVideoElement` and `HTMLAudioElement`; video-specific extensions
+ * (`fullscreen`, `pip`) live in `IVideoPlayerState`.
+ */
+export interface IMediaPlayerState {
+    /** True while the element is decoding frames / producing audio. */
+    playing: Ref<boolean>;
+    /** True when playback is paused (or has not started yet). */
+    paused: Ref<boolean>;
+    /** Current playhead position in seconds. */
+    currentTime: Ref<number>;
+    /**
+     * Total duration in seconds. `NaN` until metadata loads. Can be
+     * `Infinity` for live streams — consumers must guard `max` UI
+     * bindings with `Number.isFinite()`.
+     */
+    duration: Ref<number>;
+    /**
+     * End of the buffered range in seconds (the right edge of the last
+     * contiguous chunk the browser can play without stalling).
+     */
+    buffered: Ref<number>;
+    /** Volume between 0 and 1 — independent from `muted`. */
+    volume: Ref<number>;
+    /** True when the output is muted. Independent from `volume`. */
+    muted: Ref<boolean>;
+    /** True once metadata has loaded and `duration` is finite. */
+    ready: Ref<boolean>;
+    /** True between `loadstart` and `loadedmetadata` (or `waiting`). */
+    loading: Ref<boolean>;
+    /** Last media error captured by the composable, if any. */
+    error: Ref<MediaError | Error | null>;
+    /** Current playback rate. `1` = normal speed. */
+    playbackRate: Ref<number>;
+    /** True when at least one Remote Playback device is reachable. */
+    remoteAvailable: Ref<boolean>;
+    /** Connection state of the Remote Playback session. */
+    remoteState: Ref<'disconnected' | 'connecting' | 'connected'>;
+}
+/**
+ * Imperative methods returned by `useMediaPlayer`. Media-agnostic
+ * subset — every method maps 1:1 to the standard `HTMLMediaElement`
+ * API. Video-specific commands (`toggleFullscreen`, `togglePip`,
+ * `enterFullscreen`, …) live in `IVideoPlayerMethods`.
+ */
+export interface IMediaPlayerMethods {
+    /** Resolve once `el.play()` has settled (or the call has been
+     *  swallowed into `state.error`). */
+    play: () => Promise<void>;
+    /** Pause playback. Returns synchronously. */
+    pause: () => void;
+    /** Toggle between play and pause based on the current `playing`
+     *  state. Convenience over `if (playing) pause() else play()`. */
+    toggle: () => Promise<void>;
+    /** Seek to `seconds`, clamped to `[0, duration]`. */
+    seek: (seconds: number) => void;
+    /** Set the volume, clamped to `[0, 1]`. Un-mutes when raising
+     *  the volume from zero. */
+    setVolume: (value: number) => void;
+    /** Flip the muted flag on the element. */
+    toggleMute: () => void;
+    /** Force a reload of the underlying media element. */
+    load: () => void;
+    /** Jump backward by `seconds`, clamped to [0, duration]. */
+    skipBackward: (seconds: number) => void;
+    /** Jump forward by `seconds`, clamped to [0, duration]. */
+    skipForward: (seconds: number) => void;
+    /** Set the playback rate, clamped to `[0.25, 4]`. */
+    setPlaybackRate: (rate: number) => void;
+    /** Open the native cast / AirPlay device picker. No-op when the
+     *  Remote Playback API is unavailable. */
+    requestRemotePlayback: () => Promise<void>;
+    /** Force-disconnect any active Remote Playback session. No-op
+     *  when no session is active or the API is unavailable. */
+    stopRemotePlayback: () => Promise<void>;
+}
+/**
+ * Shared media event signatures. Composables themselves do NOT emit —
+ * consumers wire their own emits from the state refs. This interface
+ * is kept for documentation + for components that want to surface
+ * the same shape on their public emit contract.
+ */
+export interface IMediaPlayerEmits {
+    (e: 'play'): void;
+    (e: 'pause'): void;
+    (e: 'ended'): void;
+    (e: 'timeupdate', currentTime: number): void;
+    (e: 'volumechange', volume: number): void;
+    (e: 'loadedmetadata', payload: {
+        duration: number;
+    }): void;
+    (e: 'error', err: MediaError | Error): void;
+    /** Two-way binding for the playback rate. The component DOES NOT
+     *  set this in response to the consumer's prop changes — only when
+     *  the user picks a rate from the config menu. */
+    (e: 'update:playbackRate', rate: number): void;
+}
+/**
+ * Options accepted by `useMediaPlayer`. The composable is media-agnostic
+ * — `mediaRef` accepts any `HTMLMediaElement` (audio OR video).
+ */
+export interface IUseMediaPlayerOptions {
+    /** Suppress autoplay when the user has requested reduced motion. */
+    autoplay?: boolean;
+    /** Initial muted state. */
+    muted?: boolean;
+    /** Loop on `ended`. */
+    loop?: boolean;
+    /** Buffering hint. */
+    preload?: 'none' | 'metadata' | 'auto';
+    /**
+     * Resolves to the `HTMLMediaElement` to drive. When omitted, the
+     * composable creates an empty ref and expects the consumer to
+     * `bind` it on a `<video ref>` / `<audio ref>` themselves.
+     */
+    mediaRef?: Ref<HTMLMediaElement | null>;
+}

package/dist/src/interfaces/Media/media-scrubber.interface.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/interfaces/Media/media-scrubber.interface.d.ts

@@ -0,0 +1,129 @@
+import type { IColorProps, ICommonsComponentProps, IRoundedProps } from '../../interfaces';
+import type { TMediaScrubberOrientation } from '../../types';
+/**
+ * Props for `<OrigamMediaScrubber>` — a headless, media-agnostic
+ * value-on-a-track widget. Owns NO state: the parent controls
+ * `modelValue` and listens to `update:modelValue` / `change` / `drag*`
+ * / `hover` events. Used internally by `<OrigamVideo>` (and soon
+ * `<OrigamAudio>`) for the timeline AND the volume slider — both share
+ * the exact same drag / keyboard / ARIA pipeline; only the orientation
+ * and the `buffered` channel differ.
+ *
+ * Defaults are inlined inside `withDefaults` (cf. CLAUDE.md
+ * `withDefaults` rule) — this interface only types the public API.
+ */
+export interface IMediaScrubberProps extends ICommonsComponentProps, IColorProps, IRoundedProps {
+    /**
+     * Current value, between `min` and `max`. Supports `v-model`.
+     * The component never mutates this directly — every change is
+     * surfaced via `update:modelValue` so the parent stays the
+     * single source of truth.
+     */
+    modelValue: number;
+    /**
+     * Lower bound of the value range.
+     *
+     * @default 0
+     */
+    min?: number;
+    /**
+     * Upper bound of the value range. Required to compute the thumb
+     * position. Passing `0` (or any value `<= min`) freezes the
+     * scrubber at the start.
+     */
+    max: number;
+    /**
+     * Discrete step. `0` (default) means continuous — pointer events
+     * emit the raw float; positive values snap each emission to the
+     * nearest multiple.
+     *
+     * @default 0
+     */
+    step?: number;
+    /**
+     * Optional buffered position (typically the end of the browser's
+     * media buffer). Renders the `__buffer` bar from `min` up to
+     * `buffered`. Pass `undefined` to hide the bar entirely.
+     */
+    buffered?: number;
+    /**
+     * Layout axis. Horizontal = YouTube timeline shape, Vertical =
+     * volume / level meter shape (top of track = `max`,
+     * bottom of track = `min`).
+     *
+     * @default 'horizontal'
+     */
+    orientation?: TMediaScrubberOrientation;
+    /**
+     * Disables pointer + keyboard interaction. The element drops out
+     * of the tab order (`tabindex="-1"`) and pointer events become
+     * no-ops; styling stays untouched so consumers can paint their
+     * own disabled state via `:has(.origam-media-scrubber--disabled)`
+     * or similar.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Hides the thumb at rest and reveals it on hover / focus / drag —
+     * the YouTube pattern. When `false`, the thumb is always visible.
+     *
+     * @default false
+     */
+    showThumbOnHoverOnly?: boolean;
+    /**
+     * Shows a tooltip above the cursor (horizontal only) reflecting
+     * the hovered value. Content can be overridden via the `#tooltip`
+     * slot.
+     *
+     * @default false
+     */
+    showHoverTooltip?: boolean;
+    /**
+     * Formatter for the default hover tooltip label. Receives the
+     * hovered value, returns the string to render.
+     *
+     * @default value => String(value)
+     */
+    formatHoverTooltip?: (value: number) => string;
+    /**
+     * Required accessibility label — read by screen readers when the
+     * scrubber gains focus. Always pass a translated string here.
+     */
+    ariaLabel: string;
+    /**
+     * Optional human-readable representation of the current value
+     * (e.g. `"1:23"` for a timestamp, `"45 %"` for a volume).
+     * Mapped to `aria-valuetext`.
+     */
+    ariaValueText?: string;
+}
+/**
+ * Emits for `<OrigamMediaScrubber>`.
+ */
+export interface IMediaScrubberEmits {
+    /** Live value update — fires during drag, keyboard, and click. */
+    (e: 'update:modelValue', value: number): void;
+    /** Commit event — fires on pointerup / pointercancel after a drag. */
+    (e: 'change', value: number): void;
+    /** Drag has started (pointerdown captured). */
+    (e: 'dragstart'): void;
+    /** Drag has ended (pointerup / pointercancel). */
+    (e: 'dragend'): void;
+    /** Hover position — fires with the hovered value on pointermove,
+     *  and with `null` on pointerleave (cursor left the track). */
+    (e: 'hover', value: number | null): void;
+}
+/**
+ * Slot signatures for `<OrigamMediaScrubber>`.
+ */
+export interface IMediaScrubberSlots {
+    /**
+     * Hover-tooltip body. Receives the hovered value. Only rendered
+     * when `showHoverTooltip=true` AND the cursor sits over the
+     * track (horizontal orientation).
+     */
+    tooltip?: (bindings: {
+        value: number;
+    }) => any;
+}

package/dist/src/interfaces/Media/media-volume-control.interface.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/interfaces/Media/media-volume-control.interface.d.ts

@@ -0,0 +1,68 @@
+import type { ICommonsComponentProps } from '../../interfaces';
+/**
+ * Props for `<OrigamMediaVolumeControl>` — the mute / unmute button
+ * AND the YouTube-style vertical scrubber tooltip that opens on
+ * hover above it.
+ *
+ * Owns:
+ *  - the off/low/medium/high icon swap (driven by `volume` + `muted`),
+ *  - the resolvedVolume collapse (slider sits at 0 when muted=true so
+ *    the user can drag-up to unmute in a single gesture),
+ *  - the tooltip percentage formatter.
+ *
+ * Does NOT own the underlying `methods.toggleMute()` /
+ * `methods.setVolume()` calls — emits `update:muted` and
+ * `update:volume` so the parent stays the source of truth for
+ * media-side mutations.
+ */
+export interface IMediaVolumeControlProps extends ICommonsComponentProps {
+    /**
+     * Linear volume in `[0, 1]`. Typically `state.volume.value`.
+     * Required.
+     */
+    volume: number;
+    /**
+     * Whether the media is muted. When `true`, the slider collapses
+     * to 0 (resolvedVolume rule) and the icon becomes VOLUME_OFF.
+     * Required.
+     */
+    muted: boolean;
+    /**
+     * `aria-label` rendered on the toggle button when the media is
+     * NOT muted (clicking will mute). Already-translated. Required.
+     */
+    muteLabel: string;
+    /**
+     * `aria-label` rendered on the toggle button when the media IS
+     * muted (clicking will unmute). Already-translated. Required.
+     */
+    unmuteLabel: string;
+    /**
+     * `aria-label` rendered on the vertical scrubber inside the
+     * tooltip. Already-translated. Required.
+     */
+    volumeLabel: string;
+    /**
+     * Optional `data-cy` prefix used on the toggle button. The
+     * tooltip wrapper + scrubber expose their own selectors via
+     * convention (`${dataCy}-wrapper`, `${dataCy}-scrubber`).
+     *
+     * @default 'origam-media-volume-control'
+     */
+    dataCy?: string;
+}
+/**
+ * Emits surfaced by `<OrigamMediaVolumeControl>`. The atom does NOT
+ * call `methods.*` directly; the parent owns the media-side
+ * mutations.
+ */
+export interface IMediaVolumeControlEmits {
+    /** The mute toggle button was clicked. Payload is the proposed
+     *  new muted state (i.e. `!muted`). */
+    (e: 'update:muted', muted: boolean): void;
+    /** The vertical scrubber moved. Payload is the new linear
+     *  volume in `[0, 1]`. The parent must call `setVolume()` AND
+     *  toggle mute as appropriate (rising from 0 → unmute, falling
+     *  to 0 → mute). */
+    (e: 'update:volume', volume: number): void;
+}

package/dist/src/interfaces/Menu/menu.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IListItemProps, IListProps, IOverlayProps } from '../../interfaces';
+import type { ICommonsComponentEmits, IListItemProps, IListProps, IOverlayProps } from '../../interfaces';
 export interface IMenuProvide {
     register(): void;
     unregister(): void;
@@ -7,3 +7,9 @@ export interface IMenuProvide {
 export interface IMenuProps extends IOverlayProps, IListProps, IListItemProps {
     id?: string;
 }
+/** Emits fired by `<OrigamMenu>` — v-model on the open state plus the
+ *  native `contextmenu` bubble forwarded for parents that want to
+ *  show their own context menu instead. */
+export interface IMenuEmits extends ICommonsComponentEmits {
+    (e: 'contextmenu', event: MouseEvent): void;
+}

package/dist/src/interfaces/NumberField/number-field.interface.d.ts

@@ -1,6 +1,6 @@
-import type { IAdjacentInnerProps, IBorderProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IFieldEmits, IFieldProps, IFieldSlots, IInputEmits, IInputProps, IInputSlots, IMarginProps, IPaddingProps, IRoundedProps, IVariantProps } from "../../interfaces";
+import type { IFieldEmits, IFieldProps, IFieldSlots, IInputEmits, IInputProps, IInputSlots, IVariantProps } from "../../interfaces";
 import type { TIcon } from "../../types";
-export interface INumberFieldProps extends ICommonsComponentProps, IColorProps, IDensityProps, IFieldProps, IInputProps, IPaddingProps, IMarginProps, IBorderProps, IRoundedProps, IElevationProps, IVariantProps, IAdjacentInnerProps {
+export interface INumberFieldProps extends IFieldProps, IInputProps, IVariantProps {
     autofocus?: boolean;
     placeholder?: string;
     persistentPlaceholder?: boolean;

package/dist/src/interfaces/NumberFormat/number-format.interface.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/interfaces/NumberFormat/number-format.interface.d.ts

@@ -0,0 +1,161 @@
+import type { ICommonsComponentProps, ITagProps } from '../../interfaces';
+import type { TNumberFormatCompactDisplay, TNumberFormatCurrencyDisplay, TNumberFormatFormat, TNumberFormatLocale, TNumberFormatNotation, TNumberFormatSignDisplay, TNumberFormatUnitDisplay, TNumberFormatUseGrouping } from '../../types';
+/**
+ * Props for `<OrigamNumberFormat>` — pure-display i18n number renderer
+ * powered by `Intl.NumberFormat` (zero external dep).
+ *
+ * The component owns NO state: it transforms `value` through the
+ * resolved `Intl` instance and emits the result into a `<tag>` element
+ * (default `<span>`). Consumers who want to override the rendering
+ * granularly use the scoped `#default` slot which exposes
+ * `{ formatted, parts, value }`.
+ */
+export interface INumberFormatProps extends ICommonsComponentProps, ITagProps {
+    /**
+     * Number to render. Strings are parsed via `Number()` — callers can
+     * pass a stringified BigInt-like to preserve precision before
+     * coercion (the actual formatting still goes through `Number`, so
+     * values beyond `Number.MAX_SAFE_INTEGER` may lose accuracy).
+     */
+    value: number | string;
+    /**
+     * High-level format dialect — see `TNumberFormatFormat`.
+     *
+     * @default 'decimal'
+     */
+    format?: TNumberFormatFormat;
+    /**
+     * BCP-47 locale tag (or array, for fallback chains). The literal
+     * string `'auto'` triggers the runtime resolution chain (`<html
+     * lang>` → `navigator.language` → `'en-US'`).
+     *
+     * @default 'auto'
+     */
+    locale?: TNumberFormatLocale;
+    /**
+     * ISO 4217 currency code. Required when `format === 'currency'`; we
+     * fall back to `'USD'` rather than throwing so storybook controls
+     * remain forgiving.
+     *
+     * @default 'USD' (only when format === 'currency')
+     */
+    currency?: string;
+    /**
+     * Currency-symbol rendering — `'symbol'` (`$`), `'narrowSymbol'`
+     * (`$` instead of `US$`), `'code'` (`USD`) or `'name'`
+     * (`US dollar`).
+     *
+     * @default 'symbol'
+     */
+    currencyDisplay?: TNumberFormatCurrencyDisplay;
+    /**
+     * Sanctioned unit identifier (e.g. `'kilometer-per-hour'`,
+     * `'celsius'`, `'liter'`). Required when `format === 'unit'`. The
+     * full ECMAScript-sanctioned list is exposed under
+     * `Intl.supportedValuesOf('unit')` at runtime.
+     */
+    unit?: string;
+    /**
+     * Unit-label rendering — `'short'` (`km/h`), `'long'`
+     * (`kilometers per hour`) or `'narrow'` (`kph`).
+     *
+     * @default 'short'
+     */
+    unitDisplay?: TNumberFormatUnitDisplay;
+    /**
+     * Raw `notation` override. Auto-set to `'compact'` when `format ===
+     * 'compact'`, to `'scientific'` / `'engineering'` for the matching
+     * formats. Explicit values still win — useful for `format:
+     * 'decimal'` with `notation: 'scientific'`.
+     */
+    notation?: TNumberFormatNotation;
+    /**
+     * Compact-notation rendering — `'short'` (`1M`) or `'long'`
+     * (`1 million`). Only honoured when `notation === 'compact'`.
+     *
+     * @default 'short'
+     */
+    compactDisplay?: TNumberFormatCompactDisplay;
+    /** Minimum digits after the decimal point. */
+    minimumFractionDigits?: number;
+    /** Maximum digits after the decimal point. */
+    maximumFractionDigits?: number;
+    /** Minimum significant digits (mutually exclusive with fraction digits). */
+    minimumSignificantDigits?: number;
+    /** Maximum significant digits (mutually exclusive with fraction digits). */
+    maximumSignificantDigits?: number;
+    /**
+     * Thousands-separator behaviour. `true` / `'auto'` keep the locale
+     * default, `false` removes them, `'always'` forces them on, `'min2'`
+     * only renders them when the integer part has at least 2 groups.
+     *
+     * @default true
+     */
+    useGrouping?: TNumberFormatUseGrouping;
+    /**
+     * Sign-display strategy. `'auto'` (default — only negatives),
+     * `'always'`, `'except-zero'`, `'negative'`, `'never'`.
+     *
+     * @default 'auto'
+     */
+    signDisplay?: TNumberFormatSignDisplay;
+}
+/**
+ * Bindings exposed by the scoped `#default` slot. Consumers use these
+ * to highlight specific parts of the formatted output (currency symbol,
+ * decimal separator, …) without re-running `Intl.NumberFormat`
+ * themselves.
+ */
+export interface INumberFormatScopedSlotBindings {
+    /** The locale-formatted string, ready to render. */
+    formatted: string;
+    /** The structured parts (`Intl.NumberFormatPart[]`). */
+    parts: Intl.NumberFormatPart[];
+    /** The numeric value after string-to-number coercion. */
+    value: number;
+}
+/**
+ * Slot signatures for `<OrigamNumberFormat>`.
+ */
+export interface INumberFormatSlots {
+    /**
+     * Custom render override. Scoped — receives the resolved value plus
+     * the structured parts so consumers can paint individual segments.
+     */
+    default?: (bindings: INumberFormatScopedSlotBindings) => any;
+}
+/**
+ * Options accepted by `useNumberFormat`. Mirrors the public props of
+ * `<OrigamNumberFormat>` minus the wiring concerns (`tag`, `class`,
+ * `style`).
+ */
+export interface IUseNumberFormatOptions {
+    /** Same semantics as `INumberFormatProps.format`. */
+    format?: TNumberFormatFormat;
+    /** Same semantics as `INumberFormatProps.locale`. */
+    locale?: TNumberFormatLocale;
+    /** Same semantics as `INumberFormatProps.currency`. */
+    currency?: string;
+    /** Same semantics as `INumberFormatProps.currencyDisplay`. */
+    currencyDisplay?: TNumberFormatCurrencyDisplay;
+    /** Same semantics as `INumberFormatProps.unit`. */
+    unit?: string;
+    /** Same semantics as `INumberFormatProps.unitDisplay`. */
+    unitDisplay?: TNumberFormatUnitDisplay;
+    /** Same semantics as `INumberFormatProps.notation`. */
+    notation?: TNumberFormatNotation;
+    /** Same semantics as `INumberFormatProps.compactDisplay`. */
+    compactDisplay?: TNumberFormatCompactDisplay;
+    /** Same semantics as `INumberFormatProps.minimumFractionDigits`. */
+    minimumFractionDigits?: number;
+    /** Same semantics as `INumberFormatProps.maximumFractionDigits`. */
+    maximumFractionDigits?: number;
+    /** Same semantics as `INumberFormatProps.minimumSignificantDigits`. */
+    minimumSignificantDigits?: number;
+    /** Same semantics as `INumberFormatProps.maximumSignificantDigits`. */
+    maximumSignificantDigits?: number;
+    /** Same semantics as `INumberFormatProps.useGrouping`. */
+    useGrouping?: TNumberFormatUseGrouping;
+    /** Same semantics as `INumberFormatProps.signDisplay`. */
+    signDisplay?: TNumberFormatSignDisplay;
+}

package/dist/src/interfaces/Nuxt/nuxt-module.interface.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/src/interfaces/Nuxt/nuxt-module.interface.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Options passed by a consumer in `nuxt.config.ts` under the `origam` key.
+ *
+ * All fields are optional — the module applies sensible defaults (see
+ * `DEFAULTS` in `src/nuxt/module.ts`). Themes are auto-injected as CSS
+ * imports; the active theme is resolved SSR-side via cookie and the
+ * `Sec-CH-Prefers-Color-Scheme` client hint to avoid FOUC and hydration
+ * mismatches.
+ */
+export interface IOrigamNuxtModuleOptions {
+    /**
+     * Theme names whose CSS file must be loaded. Each name must match a
+     * generated `dist/src/assets/css/tokens/{theme}.css` exposed via
+     * `origam/tokens/css/{theme}`.
+     *
+     * @default ['light', 'dark']
+     */
+    themes?: string[];
+    /**
+     * Theme applied when no cookie is set and no usable
+     * `Sec-CH-Prefers-Color-Scheme` hint is sent. Use `'auto'` to let the
+     * server fall back to the client hint (or `'light'` if absent).
+     *
+     * @default 'auto'
+     */
+    defaultTheme?: string;
+    /**
+     * Cookie name used to persist the user's chosen theme across sessions.
+     *
+     * @default 'origam-theme'
+     */
+    cookieName?: string;
+    /**
+     * Cookie `max-age` in seconds.
+     *
+     * @default 31_536_000 (1 year)
+     */
+    cookieMaxAge?: number;
+    /**
+     * Register components and composables as Nuxt auto-imports. Disable if
+     * you want to opt-out and import everything explicitly (or namespace
+     * the imports to avoid conflicts with another design system).
+     *
+     * @default true
+     */
+    autoImport?: boolean;
+    /**
+     * Inject the generated utility classes stylesheet (`origam-utilities.css`).
+     * Keep it on unless the consumer ships their own utility layer.
+     *
+     * @default true
+     */
+    includeUtilities?: boolean;
+    /**
+     * Prefix applied to auto-imported components. Origam ships components
+     * already prefixed `Origam*` so the default is an empty prefix — set
+     * this to override if you need a custom namespace.
+     *
+     * @default 'Origam'
+     */
+    prefix?: string;
+}
+/**
+ * Shape of the public runtime config exposed by the module on
+ * `useRuntimeConfig().public.origam`. The plugins read this at boot to
+ * resolve the active theme and configure the cookie.
+ */
+export interface IOrigamNuxtRuntimeConfig {
+    themes: string[];
+    defaultTheme: string;
+    cookieName: string;
+    cookieMaxAge: number;
+}

package/dist/src/interfaces/OtpInputField/otp-input-field.interface.d.ts

@@ -1,6 +1,6 @@
-import type { IColorProps, ICommonsComponentProps, IDensityProps, IDimensionProps, IElevationProps, IFieldEmits, IFieldProps, IFieldSlots, IFocusProps, IInputEmits, IInputProps, IInputSlots, IRoundedProps, IVariantProps } from "../../interfaces";
+import type { IFieldEmits, IFieldProps, IFieldSlots, IInputEmits, IInputProps, IInputSlots, IVariantProps } from "../../interfaces";
 import type { TOtpInputFieldType } from "../../types";
-export interface IOtpInputFieldProps extends ICommonsComponentProps, IColorProps, IDensityProps, IDimensionProps, IFieldProps, IInputProps, IRoundedProps, IElevationProps, IVariantProps, IFocusProps {
+export interface IOtpInputFieldProps extends IFieldProps, IInputProps, IVariantProps {
     autofocus?: boolean;
     divider?: string;
     focusAll?: boolean;

package/dist/src/interfaces/Overlay/overlay-scrim.interface.d.ts

@@ -1,7 +1,14 @@
-import type { ICommonsComponentProps, ITagProps, ITransitionComponentProps } from '../../interfaces';
+import type { IClickEmits, ICommonsComponentProps, ITagProps, ITransitionComponentProps } from '../../interfaces';
 export interface IOverlayScrimProps extends ICommonsComponentProps, ITagProps, ITransitionComponentProps, IScrimProps {
     active?: boolean;
 }
 export interface IScrimProps {
     scrim?: boolean | string;
 }
+/** Emits fired by `<OrigamOverlayScrim>` — click + pointer hover events
+ *  surface to the parent overlay (so it can close on backdrop click
+ *  or pause its auto-close timer while the pointer is over the scrim). */
+export interface IOverlayScrimEmits extends IClickEmits {
+    (e: 'mouseenter', event: MouseEvent): void;
+    (e: 'mouseleave', event: MouseEvent): void;
+}

package/dist/src/interfaces/Overlay/overlay.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IActivatorProps, ICommonsComponentProps, IDimensionProps, ILazyProps, ILocationStrategyProps, IScrimProps, IScrollStrategyProps, ITransitionComponentProps } from '../../interfaces';
+import type { IActivatorProps, IClickOutsideEmits, ICommonsComponentEmits, ICommonsComponentProps, IDimensionProps, ILazyProps, ILocationStrategyProps, IScrimProps, IScrollStrategyProps, ITransitionComponentProps } from '../../interfaces';
 export interface IOverlayProps extends ICommonsComponentProps, IDimensionProps, IActivatorProps, ILocationStrategyProps, IScrollStrategyProps, ILazyProps, ITransitionComponentProps, IScrimProps {
     absolute?: boolean;
     attach?: boolean | string | Element;
@@ -12,3 +12,10 @@ export interface IOverlayProps extends ICommonsComponentProps, IDimensionProps,
     disableGlobalStack?: boolean;
     persistent?: boolean;
 }
+/** Emits fired by `<OrigamOverlay>` — v-model on the open state, outside
+ *  click, transition lifecycle hooks, and keyboard bubble. */
+export interface IOverlayEmits extends ICommonsComponentEmits, IClickOutsideEmits {
+    (e: 'afterEnter'): void;
+    (e: 'afterLeave'): void;
+    (e: 'keydown', event: KeyboardEvent): void;
+}

package/dist/src/interfaces/Pagination/pagination.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IBorderProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IMarginProps, IPaddingProps, ISizeProps, ITagProps } from "../../interfaces";
+import type { IBorderProps, IBgColorProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IMarginProps, IPaddingProps, ISizeProps, ITagProps } from "../../interfaces";
 import type { TIcon } from "../../types";
 export interface IPaginationProps extends ICommonsComponentProps, ITagProps, IColorProps, IBgColorProps, IBorderProps, IPaddingProps, IMarginProps, IElevationProps, ISizeProps, IDensityProps {
     start?: number;
@@ -57,3 +57,11 @@ export interface IPaginationProps extends ICommonsComponentProps, ITagProps, ICo
      */
     nextText?: string;
 }
+/** Emits fired by `<OrigamPagination>` — current page v-model + the four
+ *  navigation shortcuts (first / prev / next / last). */
+export interface IPaginationEmits extends ICommonsComponentEmits {
+    (e: 'first', value: number): void;
+    (e: 'prev', value: number): void;
+    (e: 'next', value: number): void;
+    (e: 'last', value: number): void;
+}