origam 2.14.1 → 2.16.0

package/dist/src/interfaces/List/list-subheader.interface.d.ts

@@ -4,3 +4,9 @@ export interface IListSubheader extends ICommonsComponentProps, ITagProps, IColo
     sticky?: boolean;
     title?: string;
 }
+/** Slot signatures for `<OrigamListSubheader>`. */
+export interface IListSubheaderSlots {
+    default?: (data: {
+        title?: string;
+    }) => any;
+}

package/dist/src/interfaces/List/list.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IBorderProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IDimensionProps, IElevationProps, IMarginProps, INestedProps, IPaddingProps, IRoundedProps, ISizeProps, ITagProps } from '../../interfaces';
+import type { IBorderProps, IBgColorProps, IColorProps, ICommonsComponentProps, IDensityProps, IDimensionProps, IElevationProps, IInternalListItem, IInternalListItemChildren, IListGroupActivatorSlotProps, IMarginProps, INestedProps, IPaddingProps, IRoundedProps, ISizeProps, ITagProps } from '../../interfaces';
 import type { TLines, TSelectItemKey } from '../../types';
 import { deepEqual } from '../../utils';
 /**
@@ -44,3 +44,23 @@ export interface IListEmits {
         path: Array<unknown>;
     }): void;
 }
+/**
+ * Slot signatures for `<OrigamList>`. All slots below `default` are
+ * forwarded straight through to the nested `<OrigamListChildren>` —
+ * `divider` / `subheader` / `group` / `item` receive the destructured
+ * `itemProps` object SPREAD as the scope (`v-bind="itemProps"`, not
+ * `v-bind="{itemProps}"`), `childrenItem` mirrors ListChildren's own
+ * `children` slot scope.
+ */
+export interface IListSlots {
+    default?: () => any;
+    childrenItem?: (data: {
+        item: IInternalListItemChildren;
+        index: number;
+    }) => any;
+    divider?: (props: IInternalListItem['props']) => any;
+    subheader?: (props: IInternalListItem['props']) => any;
+    group?: (props: IInternalListItem['props']) => any;
+    groupActivator?: (data: IListGroupActivatorSlotProps) => any;
+    item?: (props: IInternalListItem['props']) => any;
+}

package/dist/src/interfaces/Mask/mask-options.interface.d.ts

@@ -1,4 +1,5 @@
-import type { TPatternValidator } from '../../types';
+import type { Ref } from 'vue';
+import type { TMaskTokenKind, TPatternValidator } from '../../types';
 /**
  * Configuration object accepted by `useMask` / the
  * `OrigamTextField.mask` prop in its long form.
@@ -42,7 +43,27 @@ export interface IMaskApplyResult {
  * (`#`, `A`, `*`) or is a literal kept verbatim.
  */
 export interface IMaskToken {
-    kind: 'digit' | 'letter' | 'any' | 'literal';
+    kind: TMaskTokenKind;
     char: string;
     consumer: boolean;
 }
+/**
+ * Public return shape of `useMask`.
+ */
+export interface IUseMaskReturn {
+    masked: Ref<string>;
+    unmasked: Ref<string>;
+    isValid: Ref<boolean>;
+    complete: Ref<boolean>;
+    /**
+     * Imperatively re-run the formatter on a raw value
+     * (used by paste / external sync). Returns the new
+     * `unmasked` so callers can keep their model in sync.
+     */
+    setRaw: (raw: string) => string;
+    /**
+     * Currently resolved config (pattern + validator +
+     * required). `null` when no mask is active.
+     */
+    config: Ref<IResolvedMaskConfig | null>;
+}

package/dist/src/interfaces/Masonry/masonry.interface.d.ts

@@ -1,5 +1,6 @@
 import type { IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDimensionProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
 import type { TGridGapSize, TMasonryAlign } from '../../types';
+import type { Ref } from 'vue';
 /**
  * Map of `min-width` (px) → number of columns to apply when the
  * container is at least that wide. Container-query based (NOT viewport),
@@ -78,3 +79,57 @@ export interface IMasonryProps extends ICommonsComponentProps, ITagProps, IDimen
      */
     align?: TMasonryAlign;
 }
+/**
+ * Internal layout descriptor produced by the bucket-fill algorithm.
+ * One entry per measured item. Coordinates are expressed in CSS px,
+ * relative to the masonry container's content box.
+ */
+export interface IMasonryItemRect {
+    /** Index of the item in the original DOM order. */
+    index: number;
+    /** `left` (px) of the item inside the container's content box. */
+    left: number;
+    /** `top` (px) of the item inside the container's content box. */
+    top: number;
+    /** Computed width (px) — same for every item in a given pass. */
+    width: number;
+    /** Measured height (px) — preserved from the natural item flow. */
+    height: number;
+    /** Zero-based column index the item was placed into. */
+    column: number;
+}
+/**
+ * Public layout result. The caller uses `containerHeight` to size the
+ * container (absolute-positioned children would otherwise collapse it),
+ * and `items` to read per-item coordinates for inline-style assignment.
+ */
+export interface IMasonryLayoutResult {
+    /** Final container height (px) — `max(column heights)`. */
+    containerHeight: number;
+    /** Per-item position record. Index matches the original DOM order. */
+    items: IMasonryItemRect[];
+    /** Effective column count used for this layout (post-breakpoint). */
+    columns: number;
+}
+/**
+ * Options consumed by `useMasonry`. All inputs are refs so the
+ * composable can react to prop changes from its consumer.
+ */
+export interface IUseMasonryOptions {
+    /** Default column count. Used when no breakpoint matches. */
+    columnsRef: Ref<number>;
+    /**
+     * Gap in **px** between items, both axes. The composable expects an
+     * already-resolved pixel value — string-token resolution happens in
+     * the component wrapper.
+     */
+    gapRef: Ref<number>;
+    /** Optional container-query breakpoints. */
+    breakpointsRef?: Ref<TMasonryColumnBreakpoints | undefined>;
+    /**
+     * Vertical alignment of items inside a column. `'top'` packs to the
+     * top; `'center'` shifts each column's content down by half the
+     * unused space.
+     */
+    alignRef?: Ref<TMasonryAlign>;
+}

package/dist/src/interfaces/Media/media-config-menu-item.interface.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Internal implementation detail of `<OrigamMediaController>`'s config
+ * menu (quality / speed / subtitles / download rows) — NOT part of the
+ * component's public props/emits/slots surface. Deliberately not
+ * re-exported from `src/interfaces/index.ts`: nothing outside
+ * `OrigamMediaController.vue` consumes this shape.
+ */
+export interface IConfigMenuItem {
+    title: string;
+    appendText?: string;
+    prependIcon?: string;
+    key: string;
+    value?: string | number;
+    children?: Array<IConfigMenuItem>;
+    onClick?: (event: MouseEvent) => void;
+    link?: boolean;
+    href?: string;
+    download?: string | boolean;
+    rel?: string;
+    target?: string;
+}

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

@@ -14,6 +14,14 @@ import type { TAudioLoopMode, TQualityOption } from '../../types';
  *
  * Defaults are inlined inside `withDefaults` (cf. CLAUDE.md
  * `withDefaults` rule) — this interface only types the public API.
+ *
+ * Deliberately NOT `extends IAdjacentProps`. The Controller is a full
+ * transport toolbar, not a single piece of content with a leading/
+ * trailing icon — its "adjacent" surface is the `prepend-transport` /
+ * `append-transport` SLOTS (custom buttons around the play control),
+ * not an icon/avatar PROP pair. Every icon it renders (play, volume,
+ * loop, shuffle, cast, …) is a fixed-purpose transport control, matching
+ * the same reasoning as `IPaginationProps` (first/prev/next/last).
  */
 export interface IMediaControllerProps extends ICommonsComponentProps {
     /** Reactive media state from `useMediaPlayer()` (or any

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

@@ -30,6 +30,12 @@ export interface IMediaScrubberProps extends ICommonsComponentProps, IColorProps
      * Upper bound of the value range. Required to compute the thumb
      * position. Passing `0` (or any value `<= min`) freezes the
      * scrubber at the start.
+     *
+     * A frozen range is the NORMAL mount state for a media scrubber, not
+     * an error: `OrigamMediaController` feeds `scrubberMax`, which stays
+     * `0` until `state.duration` becomes finite. `aria-valuemax` reports
+     * that empty range honestly (`0`), never the internal epsilon the
+     * component uses to keep the percentage division finite.
      */
     max: number;
     /**
@@ -100,9 +106,25 @@ export interface IMediaScrubberProps extends ICommonsComponentProps, IColorProps
      */
     ariaValueText?: string;
     /**
-     * Optional `data-cy` test selector forwarded by the parent
-     * (`OrigamMediaController`, `OrigamMediaVolumeControl`) as a
-     * camelCase Vue prop. Passed through `$attrs` to the host element.
+     * `data-cy` test selector for the host element.
+     *
+     * Declaring it as a prop REMOVES it from `$attrs`, so it is rendered
+     * explicitly by the template — it does not fall through. When a parent
+     * forwards one it WINS over the component's own literal; the literal
+     * `'origam-media-scrubber'` is only the fallback for a standalone
+     * instance nobody named.
+     *
+     * Both in-house parents forward one, so inside `<OrigamVideo>` /
+     * `<OrigamAudio>` the fallback is never what renders:
+     *   - `OrigamMediaController` → `origam-media-controller-scrubber`
+     *     (the timeline, on the `#waveform` fallback)
+     *   - `OrigamMediaVolumeControl` → its own `dataCy` verbatim, i.e.
+     *     `origam-media-controller-volume` in the default toolbar
+     *
+     * Target the composed name in tests. Asserting on the bare literal is
+     * what made `video.spec.ts` red on all three engines.
+     *
+     * @default 'origam-media-scrubber'
      */
     dataCy?: string;
 }

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

@@ -7,9 +7,27 @@ export interface IMenuProvide {
 export interface IMenuProps extends IOverlayProps, IListProps, IListItemProps {
     id?: string;
 }
-/** Emits fired by `<OrigamMenu>` — v-model on the open state plus the
+/** Emits fired by `<OrigamMenu>` — v-model on the open state, the
  *  native `contextmenu` bubble forwarded for parents that want to
- *  show their own context menu instead. */
+ *  show their own context menu instead, and `select` when the user
+ *  picks a leaf row of the `items` tree.
+ *
+ *  `select` matters because `<origam-menu :items="…">` renders its own
+ *  rows: the consumer never gets a handle on the `<origam-list-item>`
+ *  that receives the click. Without it, the only way to learn which row
+ *  was picked is to hang an `onClick` on every item object. Rows that
+ *  open a submenu do NOT emit — they are navigation, not a choice. */
 export interface IMenuEmits extends ICommonsComponentEmits {
     (e: 'contextmenu', event: MouseEvent): void;
+    (e: 'select', item: IListItemProps): void;
+}
+/** Slot signatures for `<OrigamMenu>`. `activator` only forwards the
+ *  merged `props` bag (not the inner overlay's `isActive`) — matches
+ *  the template's `v-bind="{props}"` (destructured from
+ *  `#activator="{props}"`). */
+export interface IMenuSlots {
+    activator?: (data: {
+        props: Record<string, unknown>;
+    }) => any;
+    default?: () => any;
 }

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

@@ -19,3 +19,15 @@ export interface IOverlayEmits extends ICommonsComponentEmits, IClickOutsideEmit
     (e: 'afterLeave'): void;
     (e: 'keydown', event: KeyboardEvent): void;
 }
+/** Slot signatures for `<OrigamOverlay>`. */
+export interface IOverlaySlots {
+    /** Receives the merged activator ref/events/props bag — bind it with
+     *  `v-bind="props"` on whatever element should toggle the overlay. */
+    activator?: (data: {
+        isActive: boolean;
+        props: Record<string, unknown>;
+    }) => any;
+    default?: (data: {
+        isActive: boolean;
+    }) => any;
+}

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

@@ -1,5 +1,16 @@
 import type { IBorderProps, IBgColorProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IMarginProps, IPaddingProps, ISizeProps, ITagProps, ITypographyProps } from "../../interfaces";
 import type { TColor, TIcon } from "../../types";
+/**
+ * Deliberately NOT `extends IAdjacentProps`. `IAdjacentProps` models a
+ * single leading/trailing pair around one piece of content (`prependIcon`
+ * / `appendIcon`); Pagination has FOUR fixed-purpose navigation icons
+ * (first / prev / next / last), each a distinct semantic role rather than
+ * a generic "start" / "end" slot. `prevIcon` / `nextIcon` are forwarded
+ * as `prependIcon` / `appendIcon` props to the internal `<OrigamBtn>` nav
+ * buttons (see `controls` computed in `OrigamPagination.vue`) — that's
+ * `IBtnProps.IAdjacentProps` being consumed by the child, not a surface
+ * this component itself exposes.
+ */
 export interface IPaginationProps extends ICommonsComponentProps, ITagProps, IColorProps, IBgColorProps, IBorderProps, IPaddingProps, IMarginProps, IElevationProps, ISizeProps, IDensityProps, ITypographyProps {
     start?: number;
     modelValue?: number;
@@ -80,3 +91,24 @@ export interface IPaginationEmits extends ICommonsComponentEmits {
     (e: 'next', value: number): void;
     (e: 'last', value: number): void;
 }
+/**
+ * Slot signatures for `<OrigamPagination>`. `first` / `prev` / `next` /
+ * `last` receive the resolved `<OrigamBtn>` props bag spread as the
+ * scope (`v-bind="{...controls.prev}"`, …) — a loose `Record` since the
+ * bag mixes DS button props with internal wiring (`ref`, `onClick`,
+ * `ellipsis`). Per-page overrides (`item-{key}` / `item`) are unscoped —
+ * the template renders `<slot :name="…">` with no `v-bind`.
+ */
+export interface IPaginationSlots {
+    info?: (data: {
+        start: number;
+        end: number;
+        total: number;
+    }) => any;
+    first?: (props: Record<string, unknown>) => any;
+    prev?: (props: Record<string, unknown>) => any;
+    next?: (props: Record<string, unknown>) => any;
+    last?: (props: Record<string, unknown>) => any;
+    item?: () => any;
+    [key: `item-${string}`]: (() => any) | undefined;
+}

package/dist/src/interfaces/Parallax/parallax-element.interface.d.ts

@@ -29,6 +29,10 @@ export interface IParallaxElementMovement {
     maxX?: number;
     maxY?: number;
 }
+/** Slot signatures for `<OrigamParallaxElement>`. */
+export interface IParallaxElementSlots {
+    default?: () => any;
+}
 export interface IParallaxElementCicle {
     referencePosition: TPoint;
     shape: IBox;

package/dist/src/interfaces/Parallax/parallax-layer.interface.d.ts

@@ -24,6 +24,10 @@ export interface IParallaxLayerProps extends ICommonsComponentProps, ITagProps {
      */
     zIndex?: number;
 }
+/** Slot signatures for `<OrigamParallaxLayer>`. */
+export interface IParallaxLayerSlots {
+    default?: () => any;
+}
 export interface IParallaxLayerRegistry {
     /**
      * Internal layer descriptor as registered into the parent OrigamParallax

package/dist/src/interfaces/Parallax/parallax.interface.d.ts

@@ -54,6 +54,17 @@ export interface IParallaxProps extends ICommonsComponentProps, ITagProps, IColo
      */
     threshold?: number;
 }
+/** Emits fired by `<OrigamParallax>` — mouse/scroll movement lifecycle
+ *  and live scroll-progress reporting. */
+export interface IParallaxEmits {
+    (e: 'enter'): void;
+    (e: 'leave'): void;
+    (e: 'scroll-progress', progress: number): void;
+}
+/** Slot signatures for `<OrigamParallax>`. */
+export interface IParallaxSlots {
+    default?: () => any;
+}
 export interface IParallaxProvide {
     audioData: Ref<any>;
     eventData: Ref<TPoint>;
@@ -110,3 +121,21 @@ export interface IParallaxLayerProvide {
     register: (layer: IParallaxLayerRegistry) => void;
     unregister: (id: symbol) => void;
 }
+/*********************************************************
+ * Options consumed by `useParallaxRuntime`.
+ ********************************************************/
+export interface IUseParallaxRuntimeOptions {
+    target: Ref<HTMLElement | undefined>;
+    direction: Ref<TParallaxDirection>;
+    easing: Ref<TParallaxEasing | string>;
+    threshold: Ref<number>;
+    disabled: Ref<boolean>;
+    /**
+     * Fallback speed used when `slot=default` carries raw content (no
+     * `<OrigamParallaxLayer>`). Mirrors `IParallaxProps.speed`.
+     */
+    speed: Ref<number>;
+    onEnter?: () => void;
+    onLeave?: () => void;
+    onProgress?: (progress: number) => void;
+}

package/dist/src/interfaces/Picker/picker-title.interface.d.ts

@@ -2,3 +2,8 @@ import type { IBgColorProps, IColorProps, ICommonsComponentProps, ITagProps, ITy
 export interface IPickerTitleProps extends ICommonsComponentProps, ITagProps, IColorProps, IBgColorProps, ITypographyProps {
     title?: string;
 }
+/** Slot signatures for `<OrigamPickerTitle>`. The default slot wins
+ *  over the `title` prop. */
+export interface IPickerTitleSlots {
+    default?: () => any;
+}

package/dist/src/interfaces/Picker/picker.interface.d.ts

@@ -3,3 +3,10 @@ export interface IPickerProps extends ISheetProps, IBgColorProps, IPickerTitlePr
     landscape?: boolean;
     hideHeader?: boolean;
 }
+/** Slot signatures for `<OrigamPicker>`. */
+export interface IPickerSlots {
+    title?: () => any;
+    header?: () => any;
+    default?: () => any;
+    actions?: () => any;
+}

package/dist/src/interfaces/Progress/progress-circular.interface.d.ts

@@ -2,3 +2,9 @@ import type { IProgressTypeProps, ISizeProps } from '../../interfaces';
 export interface IProgressCircularProps extends IProgressTypeProps, ISizeProps {
     rotate?: string | number;
 }
+/** Slot signatures for `<OrigamProgressCircular>`. */
+export interface IProgressCircularSlots {
+    default?: (data: {
+        value: number;
+    }) => any;
+}

package/dist/src/interfaces/Progress/progress-linear.interface.d.ts

@@ -5,3 +5,10 @@ export interface IProgressLinearProps extends IProgressTypeProps, IRoundedProps,
     reverse?: boolean;
     stream?: boolean;
 }
+/** Slot signatures for `<OrigamProgressLinear>`. */
+export interface IProgressLinearSlots {
+    default?: (data: {
+        value: number;
+        buffer: number;
+    }) => any;
+}

package/dist/src/interfaces/Progress/progress.interface.d.ts

@@ -3,6 +3,10 @@ import type { TProgressType } from '../../types';
 export interface IProgressProps extends IProgressLinearProps, IProgressCircularProps {
     type?: TProgressType;
 }
+/** Slot signatures for `<OrigamProgress>`. */
+export interface IProgressSlots {
+    default?: () => any;
+}
 export interface IProgressTypeProps extends ITagProps, ICommonsComponentProps, IColorProps, IBgColorProps, IPaddingProps, IMarginProps {
     indeterminate?: boolean;
     modelValue?: string | number;

package/dist/src/interfaces/QrCode/qr-code.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ISizeProps, ISrcObject, ITagProps } from '../../interfaces';
+import type { IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IElevationProps, IMarginProps, IPaddingProps, IRoundedProps, ISizeProps, ISrcObject, IQrCodeLogo, ITagProps } from '../../interfaces';
 import type { TIcon, TQrCodeErrorCorrectionLevel } from '../../types';
 /**
  * Per-matrix overrides — applied INSIDE the SVG (modules + quiet
@@ -150,3 +150,17 @@ export interface IQrCodeSlots {
         size: number;
     }) => any;
 }
+/**
+ * `useQrCode`'s option bag AFTER defaulting — every field resolved to a
+ * concrete value, so the SVG builders downstream never re-apply a
+ * fallback. Distinct from `IUseQrCodeOptions`, which is the loose,
+ * all-optional shape a caller passes in.
+ */
+export interface IQrCodeResolvedOptions {
+    errorCorrectionLevel: TQrCodeErrorCorrectionLevel;
+    foreground: string;
+    background: string;
+    margin: number;
+    cornerRadius: number;
+    logo?: IQrCodeLogo;
+}

package/dist/src/interfaces/Radio/radio-btn.interface.d.ts

@@ -1,6 +1,20 @@
 import type { IClickLabelEmits, ICommonsComponentEmits, ICommonsComponentProps, IFocusEmits, ISelectionControlProps } from '../../interfaces';
+import type { TColor, TIcon } from '../../types';
 export interface IRadioBtnProps extends ICommonsComponentProps, ISelectionControlProps {
 }
 /** Emits fired by `<OrigamRadioBtn>` — same surface as `<OrigamRadio>`. */
 export interface IRadioBtnEmits extends ICommonsComponentEmits, IFocusEmits, IClickLabelEmits {
 }
+/** Slot signatures for `<OrigamRadioBtn>` — forwarded, unscoped `default` /
+ *  `label`, and the same `input` scope as `<OrigamSelectionControl>`. */
+export interface IRadioBtnSlots {
+    default?: () => any;
+    input?: (data: {
+        model: any;
+        color?: TColor;
+        bgColor?: TColor;
+        icon?: TIcon;
+        props: any;
+    }) => any;
+    label?: () => any;
+}

package/dist/src/interfaces/Radio/radio-group.interface.d.ts

@@ -1,3 +1,30 @@
-import type { IBorderProps, ICommonsComponentProps, IElevationProps, IInputProps, IMarginProps, IPaddingProps, IRadioProps, IRoundedProps, ISelectionControlGroupProps } from '../../interfaces';
+import type { IBorderProps, ICommonsComponentEmits, ICommonsComponentProps, IElevationProps, IInputProps, IMarginProps, IPaddingProps, IRadioProps, IRoundedProps, ISelectionControlGroupProps } from '../../interfaces';
 export interface IRadioGroupProps extends ICommonsComponentProps, Partial<Omit<IRadioProps, 'trueValue' | 'falseValue'>>, IPaddingProps, IMarginProps, IBorderProps, IRoundedProps, IElevationProps, IInputProps, Partial<Omit<ISelectionControlGroupProps, 'multiple'>> {
 }
+/** Emits fired by `<OrigamRadioGroup>` — v-model de la valeur choisie. */
+export interface IRadioGroupEmits extends ICommonsComponentEmits {
+}
+/** Slot signatures for `<OrigamRadioGroup>`. `item` reuses the same
+ *  `{id, messagesId, isDisabled, isReadonly, isValid}` scope as
+ *  `default` (NOT the individual `item` being rendered — the template
+ *  forwards the outer `<OrigamInput>` scope unchanged). */
+export interface IRadioGroupSlots {
+    default?: (data: {
+        id: string;
+        messagesId: string;
+        isDisabled: boolean;
+        isReadonly: boolean;
+        isValid: boolean | undefined;
+    }) => any;
+    label?: (data: {
+        label?: string;
+        required?: boolean;
+    }) => any;
+    item?: (data: {
+        id: string;
+        messagesId: string;
+        isDisabled: boolean;
+        isReadonly: boolean;
+        isValid: boolean | undefined;
+    }) => any;
+}

package/dist/src/interfaces/Radio/radio.interface.d.ts

@@ -1,6 +1,40 @@
-import type { IActiveProps, IBorderProps, IClickLabelEmits, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IFocusEmits, IHoverProps, IInputProps, IMarginProps, IPaddingProps, IRadioBtnProps, IRoundedProps } from '../../interfaces';
+import type { IActiveProps, IAdjacentSlots, IBorderProps, IClickLabelEmits, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IFocusEmits, IHoverProps, IInputProps, IMarginProps, IPaddingProps, IRadioBtnProps, IRoundedProps } from '../../interfaces';
+import type { TIcon } from '../../types';
 export interface IRadioProps extends ICommonsComponentProps, IInputProps, IRadioBtnProps, IDensityProps, IPaddingProps, IMarginProps, IRoundedProps, IColorProps, IBorderProps, IElevationProps, IActiveProps, IHoverProps {
 }
 /** Emits fired by `<OrigamRadio>` — v-model + focus + label click. */
 export interface IRadioEmits extends ICommonsComponentEmits, IFocusEmits, IClickLabelEmits {
 }
+/** Slot signatures for `<OrigamRadio>` — the wrapping `<OrigamInput>`'s
+ *  chrome (`default` / `details` / `messages` / `message`, plus
+ *  `prepend` / `append`) and the nested `<OrigamRadioBtn>`'s own
+ *  `input` / `label` slots, forwarded straight through. */
+export interface IRadioSlots extends IAdjacentSlots {
+    /**
+     * Scoped when rendered at the `<OrigamInput>` level
+     * (`{id, messagesId, isDisabled, isReadonly, isValid}`), but the
+     * SAME slot is also forwarded unscoped one level down into
+     * `<OrigamRadioBtn>`'s own `default` — hence the optional param.
+     */
+    default?: (data?: {
+        id: string;
+        messagesId: string;
+        isDisabled: boolean;
+        isReadonly: boolean;
+        isValid: boolean | undefined;
+    }) => any;
+    input?: (data: {
+        props: any;
+        icon?: TIcon;
+        model: any;
+    }) => any;
+    label?: () => any;
+    details?: (props: any) => any;
+    messages?: (data: {
+        hasMessages: boolean;
+        messages: Array<string> | Record<string, string>;
+    }) => any;
+    message?: (data: {
+        message: any;
+    }) => any;
+}

package/dist/src/interfaces/RatingField/rating-field-item.interface.d.ts

@@ -24,3 +24,12 @@ export interface IRatingFieldItemEmits extends IClickEmits {
     (e: 'mouseenter', event: MouseEvent): void;
     (e: 'mouseleave', event: MouseEvent): void;
 }
+/** Slot signatures for `<OrigamRatingFieldItem>`. */
+export interface IRatingFieldItemSlots {
+    /** Overrides the star/icon button — `props` is the resolved
+     *  `<OrigamBtn>` prop bag (icon, color, ripple, click handlers…). */
+    item?: (data: {
+        props: Record<string, unknown>;
+        value: number;
+    }) => any;
+}

package/dist/src/interfaces/RatingField/rating-field.interface.d.ts

@@ -1,4 +1,4 @@
-import type { ICommonsComponentEmits, IInputProps, ILabelProps, IRippleProps, ITagProps } from '../../interfaces';
+import type { IAdjacentSlots, ICommonsComponentEmits, IInputProps, ILabelProps, IRippleProps, ITagProps } from '../../interfaces';
 import type { TBlock, TIcon } from '../../types';
 export interface IRatingFieldProps extends IInputProps, IRippleProps, ITagProps, ILabelProps {
     name?: string;
@@ -18,3 +18,29 @@ export interface IRatingFieldProps extends IInputProps, IRippleProps, ITagProps,
 /** Emits fired by `<OrigamRatingField>` — v-model on the rating value. */
 export interface IRatingFieldEmits extends ICommonsComponentEmits {
 }
+/**
+ * Slot signatures for `<OrigamRatingField>` — the wrapping
+ * `<OrigamInput>` chrome (`default` / `details` / `messages` /
+ * `message`, plus `prepend` / `append`), `label`, and per-item labels
+ * (`itemLabel.{index}` / `itemLabel`), all unscoped except `default`.
+ */
+export interface IRatingFieldSlots extends IAdjacentSlots {
+    default?: (data: {
+        id: string;
+        messagesId: string;
+        isDisabled: boolean;
+        isReadonly: boolean;
+        isValid: boolean | undefined;
+    }) => any;
+    label?: () => any;
+    itemLabel?: () => any;
+    details?: (props: any) => any;
+    messages?: (data: {
+        hasMessages: boolean;
+        messages: Array<string> | Record<string, string>;
+    }) => any;
+    message?: (data: {
+        message: any;
+    }) => any;
+    [key: `itemLabel.${number}`]: (() => any) | undefined;
+}

package/dist/src/interfaces/Responsive/responsive.interface.d.ts

@@ -4,3 +4,8 @@ export interface IResponsiveProps extends IDimensionProps, ICommonsComponentProp
     contentClass?: string;
     inline?: boolean;
 }
+/** Slot signatures for `<OrigamResponsive>`. */
+export interface IResponsiveSlots {
+    additional?: () => any;
+    default?: () => any;
+}

package/dist/src/interfaces/Select/select.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IAdjacentEmits, IAdjacentInnerEmits, IAdjacentInnerProps, IAdjacentProps, IBorderProps, IChipProps, IBgColorProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IFieldProps, IFiltersProps, IFocusEmits, IInputProps, IItemProps, ILazyProps, IListProps, IMarginProps, IMenuProps, IPaddingProps, IRoundedProps, ITextFieldProps, ITransitionComponentProps } from '../../interfaces';
+import type { IAdjacentEmits, IAdjacentInnerEmits, IAdjacentInnerProps, IAdjacentProps, IAdjacentSlots, IBorderProps, IChipProps, IBgColorProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IFieldProps, IFieldSlots, IFiltersProps, IFocusEmits, IInputProps, IInternalListItem, IItemProps, ILazyProps, IListProps, IMarginProps, IMenuProps, IPaddingProps, IRoundedProps, ITextFieldProps, ITransitionComponentProps } from '../../interfaces';
 import type { TIcon } from '../../types';
 export interface ISelectProps extends ICommonsComponentProps, IColorProps, IBgColorProps, ITextFieldProps, IDensityProps, IAdjacentProps, IAdjacentInnerProps, IFieldProps, IInputProps, IPaddingProps, IMarginProps, IBorderProps, IRoundedProps, IElevationProps, IItemProps, ITransitionComponentProps, IFiltersProps, ILazyProps {
     chips?: boolean;
@@ -29,3 +29,29 @@ export interface ISelectEmits extends ICommonsComponentEmits, IFocusEmits, IAdja
     (e: 'mousedown:control', event: MouseEvent): void;
     (e: 'update:menu', value: boolean): void;
 }
+/** Slot signatures for `<OrigamSelect>` — the field chrome slots
+ *  (`IFieldSlots` minus its scoped `default`, since this field renders
+ *  its own dropdown/selection markup instead) plus `prepend` / `append`
+ *  (`IAdjacentSlots`) and the dropdown/selection overrides. */
+export interface ISelectSlots extends Omit<IFieldSlots, 'default'>, IAdjacentSlots {
+    /** Rendered before the option list, inside the dropdown. */
+    'items.prepend'?: () => any;
+    /** Overrides the "no results" row. */
+    noData?: () => any;
+    /** Overrides one option row — `props` is the resolved `<OrigamListItem>` prop bag. */
+    item?: (data: {
+        item: IInternalListItem;
+        index: number;
+        props: Record<string, unknown>;
+    }) => any;
+    /** Rendered after the option list, inside the dropdown. */
+    'items.append'?: () => any;
+    /** Overrides one selected-value chip (`chips` mode). */
+    chip?: (data: {
+        item: IInternalListItem;
+        index: number;
+        props: Record<string, unknown>;
+    }) => any;
+    /** Overrides a single selected value's text representation. */
+    selection?: () => any;
+}