origam 2.14.1 → 2.15.0

package/dist/src/interfaces/DataTable/headers.interface.d.ts

@@ -1,6 +1,6 @@
 import type { ComputedRef, Ref, UnwrapRef } from 'vue';
 import { ALIGN } from '../../enums';
-import type { IAdjacentEmits, IBgColorProps, IColorProps, ICommonsComponentProps, IDataTableItem, IDataTableSortItem, IDisplayProps, ILoaderProps } from '../../interfaces';
+import type { IAdjacentEmits, IBgColorProps, IColorProps, ICommonsComponentProps, IDataTableHeaderCellColumnSlot, IDataTableItem, IDataTableSortItem, IDisplayProps, IInternalListItem, ILoaderProps } from '../../interfaces';
 import type { TDataTableCompareFunction, TDataTableHeaderCell, TFilterFunction, TIcon, TSelectItemKey } from '../../types';
 export interface IHeaderCellProps extends ICommonsComponentProps, IColorProps {
     disableSort?: boolean;
@@ -12,6 +12,16 @@ export interface IHeaderCellProps extends ICommonsComponentProps, IColorProps {
 }
 export interface IDataTableHeadersProps extends ICommonsComponentProps, IColorProps, IDisplayProps, ILoaderProps, IHeaderCellProps {
 }
+/**
+ * Deliberately NOT `extends IAdjacentProps`. This cell has no
+ * consumer-facing prepend/append icon prop — the `appendIcon` rendered
+ * inside it is a purely internal computed (the multi-select checkbox
+ * glyph, see `appendIcon` in `OrigamDataTableHeadersCellMobile.vue`)
+ * forwarded to the nested `<OrigamSelect>`'s own `IAdjacentProps.appendIcon`.
+ * There is no `prependIcon` counterpart because there is nothing for a
+ * consumer to set — adding one would fabricate an API this component
+ * doesn't have a use for.
+ */
 export interface IDataTableHeadersCellMobileProps extends ICommonsComponentProps, IHeaderCellProps, IColorProps {
     columns: Array<IInternalDataTableHeader>;
     colspan?: number;
@@ -21,6 +31,42 @@ export interface IDataTableHeadersCellMobileProps extends ICommonsComponentProps
 export interface IDataTableHeadersCellMobileEmits extends IAdjacentEmits {
     (e: 'click:clear', event: MouseEvent): void;
 }
+/** Scope forwarded on the `select.chip` slot — the underlying list item
+ *  behind the chip, its index, and the draft props the default chip
+ *  render would receive (spread them to keep the built-in click/close
+ *  wiring when only restyling the chip). */
+export interface IDataTableHeadersCellMobileChipSlot {
+    item: IInternalListItem;
+    index: number;
+    chipProps: Record<string, unknown>;
+}
+/** Slot signatures for `<OrigamDataTableHeadersCellMobile>` — almost
+ *  entirely pass-through onto the internal `<origam-select>` /
+ *  `<origam-chip>` it renders (mobile "sort by" picker), so most slots
+ *  carry no scope of their own; only `select.chip` exposes one. */
+export interface IDataTableHeadersCellMobileSlots {
+    'select.prepend'?: () => any;
+    'select.loader'?: () => any;
+    'select.prependInner'?: () => any;
+    'select.floatingLabel'?: () => any;
+    'select.label'?: () => any;
+    'select.prefix'?: () => any;
+    'select.chip'?: (props: IDataTableHeadersCellMobileChipSlot) => any;
+    'select.selection'?: () => any;
+    'select.noData'?: () => any;
+    'select.prependItem'?: () => any;
+    'select.item'?: () => any;
+    'select.appendItem'?: () => any;
+    'select.suffix'?: () => any;
+    'select.appendInner'?: () => any;
+    clear?: () => any;
+    'select.append'?: () => any;
+    'chip:prepend'?: () => any;
+    'chip:default'?: () => any;
+    'chip:append'?: () => any;
+    'chip:close'?: () => any;
+    'chip:filter'?: () => any;
+}
 export interface IDataTableHeadersCellProps extends ICommonsComponentProps, IColorProps, IHeaderCellProps {
     headers: Array<Array<IInternalDataTableHeader>>;
 }
@@ -40,6 +86,21 @@ export interface IDataTableHeadersSlotProps {
     getSortIcon: (column: IInternalDataTableHeader) => TIcon | undefined;
     isSorted: (column: IInternalDataTableHeader) => boolean;
 }
+/** Slot signatures for `<OrigamDataTableHeaders>` — `mobile` renders
+ *  instead of `default` once `useDisplay` flips to the mobile layout;
+ *  `loader` (the in-progress sort indicator row) carries no scope. */
+export interface IDataTableHeadersSlots {
+    mobile?: (props: IDataTableHeadersSlotProps) => any;
+    default?: (props: IDataTableHeadersSlotProps) => any;
+    loader?: () => any;
+}
+/** Slot signature for `<OrigamDataTableHeaderCell>` — the column-driven
+ *  `header.{key}` name is only known at runtime (one column definition
+ *  per header), so it's expressed as a template-literal index signature
+ *  rather than a fixed key. */
+export interface IDataTableHeaderCellSlots {
+    [key: `header.${string}`]: ((props: IDataTableHeaderCellColumnSlot) => any) | undefined;
+}
 export interface IDataTableHeaderProps {
     headers?: Array<IDataTableHeader>;
     items?: Array<IDataTableItem>;

package/dist/src/interfaces/DataTable/items.interface.d.ts

@@ -1,4 +1,3 @@
-import type { ComputedRef, Ref } from 'vue';
 import type { IDataTableGroupableItem, IDataTableSelectableItem, IDataTableSortItem, IInternalDataTableHeader, IInternalItem } from '../../interfaces';
 import type { TDataTableCell, TDataTableRow, TIcon, TSelectItemKey } from '../../types';
 export interface IDataTableItemsProps {
@@ -36,13 +35,20 @@ export interface IDataTableItemSlot<T = any> extends IDataTableItemBase<T> {
     columns: IInternalDataTableHeader[];
     props: any;
 }
+/**
+ * Scope shared by the `header.{key}` slot on `<OrigamDataTableHeaderCell>`
+ * and its forward on `<OrigamDataTableRow>` (mobile column-title cell).
+ * `sortBy` / `someSelected` / `allSelected` are the UNWRAPPED values
+ * (`ref.value`) both call sites pass — not the `Ref` / `ComputedRef`
+ * containers themselves.
+ */
 export interface IDataTableHeaderCellColumnSlot {
     column: IInternalDataTableHeader;
     selectAll: (value: boolean) => void;
     isSorted: (column: IInternalDataTableHeader) => boolean;
     toggleSort: (column: IInternalDataTableHeader) => void;
-    sortBy: Ref<Array<IDataTableSortItem>>;
-    someSelected: ComputedRef<boolean>;
-    allSelected: ComputedRef<boolean>;
-    getSortIcon: (column: IInternalDataTableHeader) => TIcon;
+    sortBy: Array<IDataTableSortItem>;
+    someSelected: boolean;
+    allSelected: boolean;
+    getSortIcon: (column: IInternalDataTableHeader) => TIcon | undefined;
 }

package/dist/src/interfaces/DataTable/row.interface.d.ts

@@ -1,4 +1,4 @@
-import type { ICommonsComponentProps, IDataTableGroup, IDataTableItem, IDisplayProps, ILoaderProps } from '../../interfaces';
+import type { ICommonsComponentProps, IDataTableGroup, IDataTableGroupHeaderSlot, IDataTableHeaderCellColumnSlot, IDataTableItem, IDataTableItemBaseSlot, IDataTableItemKey, IDataTableItemSlot, IDisplayProps, ILoaderProps } from '../../interfaces';
 import type { TDataTableCell, TDataTableRow } from '../../types';
 export interface IDataTableRowsProps extends ICommonsComponentProps, ILoaderProps, IDisplayProps {
     hideNoData?: boolean;
@@ -22,3 +22,33 @@ export interface IDataTableRowEmits {
         value: boolean;
     }): void;
 }
+/** Slot signatures for `<OrigamDataTableRows>` — the list-level renderer
+ *  (loading / empty states, then one `group-header` or `item` per row). */
+export interface IDataTableRowsSlots<T = any> {
+    loading?: () => any;
+    'no-data'?: () => any;
+    'group-header'?: (props: IDataTableGroupHeaderSlot) => any;
+    item?: (props: IDataTableItemSlot<T>) => any;
+    /**
+     * Same base scope as `group-header` / `item` (index, item,
+     * internalItem, columns + expand/select actions). The template used
+     * to forward the local `slotProps` FUNCTION reference unevaluated
+     * (`v-bind="slotProps"` instead of `v-bind="slotProps(item, index)"`),
+     * which passed an empty object at runtime — fixed alongside this type
+     * so declared and actual scope match.
+     */
+    'expanded-row'?: (props: IDataTableItemBaseSlot<T>) => any;
+}
+/** Slot signatures for `<OrigamDataTableRow>` — one row's per-column
+ *  content. Column-driven slot names (`item.{key}` / `header.{key}`) are
+ *  only known at runtime, so they're expressed as template-literal index
+ *  signatures rather than a fixed key list. The two built-in system
+ *  columns (`data-table-select`, `data-table-expand`) are also listed
+ *  explicitly for IDE discoverability — both already satisfy the
+ *  `item.${string}` pattern. */
+export interface IDataTableRowSlots {
+    'item.data-table-select'?: (props: IDataTableItemKey) => any;
+    'item.data-table-expand'?: (props: IDataTableItemKey) => any;
+    [key: `item.${string}`]: ((props: IDataTableItemKey) => any) | undefined;
+    [key: `header.${string}`]: ((props: IDataTableHeaderCellColumnSlot) => any) | undefined;
+}

package/dist/src/interfaces/DatePicker/date-picker-header.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IAdjacentProps, IColorProps, ICommonsComponentProps, IDensityProps } from "../../interfaces";
+import type { IAdjacentProps, IAdjacentSlots, IColorProps, ICommonsComponentProps, IDensityProps } from "../../interfaces";
 import type { TTransitionProps } from "../../types";
 export interface IDatePickerHeaderProps extends ICommonsComponentProps, IColorProps, IAdjacentProps, IDensityProps {
     header?: string;
@@ -8,3 +8,9 @@ export interface IDatePickerHeaderProps extends ICommonsComponentProps, IColorPr
  *  `event` is optional: the handler calls `emits('click')` without forwarding
  *  the originating MouseEvent. */
 export type IDatePickerHeaderEmits = (e: 'click', event?: MouseEvent) => void;
+/** Slot signatures for `<OrigamDatePickerHeader>` — `prepend` / `append`
+ *  render with no scope (avatar/icon slots), same contract as
+ *  `IAdjacentSlots`; `default` (the header text itself) also carries none. */
+export interface IDatePickerHeaderSlots extends IAdjacentSlots {
+    default?: () => any;
+}

package/dist/src/interfaces/DatePicker/date-picker-month.interface.d.ts

@@ -1,4 +1,4 @@
-import type { ICalendarProps, IColorProps, ICommonsComponentProps } from "../../interfaces";
+import type { ICalendarProps, IColorProps, ICommonsComponentProps, IDay } from "../../interfaces";
 import type { TTransitionProps } from "../../types";
 export interface IDatePickerMonthProps extends ICommonsComponentProps, IColorProps, ICalendarProps {
     hideWeekdays?: boolean;
@@ -8,3 +8,16 @@ export interface IDatePickerMonthProps extends ICommonsComponentProps, IColorPro
     transition?: TTransitionProps;
     reverseTransition?: TTransitionProps;
 }
+/** Scope for the `days` slot — one calendar cell. `props` is pre-wired
+ *  (`onClick`) so a custom render can spread it onto any element and still
+ *  select the day correctly. */
+export interface IDatePickerMonthDaySlot {
+    props: {
+        onClick: (event: MouseEvent) => void;
+    };
+    item: IDay;
+    index: number;
+}
+export interface IDatePickerMonthSlots {
+    days?: (props: IDatePickerMonthDaySlot) => any;
+}

package/dist/src/interfaces/DatePicker/date-picker-months.interface.d.ts

@@ -1,4 +1,5 @@
 import type { IColorProps, ICommonsComponentProps, IDimensionProps } from "../../interfaces";
+import type { TColor } from "../../types";
 export interface IDatePickerMonthsProps extends ICommonsComponentProps, IColorProps, IDimensionProps {
     min?: unknown;
     max?: unknown;
@@ -9,3 +10,29 @@ export interface IDatePickerMonthsProps extends ICommonsComponentProps, IColorPr
 export interface IDatePickerMonthsEmits {
     (e: 'update:month', value: number): void;
 }
+/** One month tile's derived state (`btnProps()`'s first argument). */
+export interface IDatePickerMonthsItem {
+    isDisabled: boolean;
+    text: string;
+    value: number;
+}
+/** Pre-wired `<origam-btn>` props (`btnProps()`'s return value) — spread
+ *  them onto a custom render to keep the active/disabled/click wiring. */
+export interface IDatePickerMonthsButtonProps {
+    active: boolean;
+    color: TColor | undefined;
+    disabled: boolean;
+    rounded: boolean;
+    text: string;
+    key: string;
+    onClick: () => void;
+}
+/** Scope for the `month` slot. */
+export interface IDatePickerMonthsSlot {
+    month: IDatePickerMonthsItem;
+    index: number;
+    props: IDatePickerMonthsButtonProps;
+}
+export interface IDatePickerMonthsSlots {
+    month?: (props: IDatePickerMonthsSlot) => any;
+}

package/dist/src/interfaces/DatePicker/date-picker-years.interface.d.ts

@@ -1,4 +1,5 @@
 import type { IColorProps, ICommonsComponentProps, IDimensionProps } from "../../interfaces";
+import type { TColor } from "../../types";
 export interface IDatePickerYearsProps extends ICommonsComponentProps, IColorProps, IDimensionProps {
     min?: unknown;
     max?: unknown;
@@ -8,3 +9,34 @@ export interface IDatePickerYearsProps extends ICommonsComponentProps, IColorPro
 export interface IDatePickerYearsEmits {
     (e: 'update:year', value: number): void;
 }
+/** One year tile's derived state (`btnProps()`'s first argument). */
+export interface IDatePickerYearsItem {
+    text: string;
+    value: number;
+}
+/** Pre-wired `<origam-btn>` props (`btnProps()`'s return value) — spread
+ *  them onto a custom render to keep the active/scroll-into-view/click
+ *  wiring. `ref` is only set on the currently-selected tile (drives the
+ *  mount-time `scrollIntoView`). Typed `unknown`, not `TTemplateRef`: Vue
+ *  treats an object's `ref` key as a reserved vnode binding and rewrites
+ *  its type through its own `Ref`-unwrapping machinery at the template
+ *  boundary, so the concrete `templateRef()` return type never survives
+ *  the round-trip — this field exists for spreading, not for reading. */
+export interface IDatePickerYearsButtonProps {
+    ref: unknown;
+    active: boolean;
+    color: TColor | undefined;
+    rounded: boolean;
+    text: string;
+    key: string;
+    onClick: () => void;
+}
+/** Scope for the `year` slot. */
+export interface IDatePickerYearsSlot {
+    year: IDatePickerYearsItem;
+    index: number;
+    props: IDatePickerYearsButtonProps;
+}
+export interface IDatePickerYearsSlots {
+    year?: (props: IDatePickerYearsSlot) => any;
+}

package/dist/src/interfaces/DatePicker/date-picker.interface.d.ts

@@ -1,5 +1,5 @@
 import type { IBorderProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDatePickerControlsProps, IDatePickerHeaderProps, IDatePickerMonthProps, IDatePickerMonthsProps, IDatePickerYearsProps, IElevationProps, IMarginProps, IPaddingProps, IPickerProps, IRoundedProps } from "../../interfaces";
-import type { TDateMode } from "../../types";
+import type { TDateMode, TTransitionProps } from "../../types";
 export interface IDatePickerProps extends ICommonsComponentProps, IColorProps, IBorderProps, IRoundedProps, IElevationProps, IPaddingProps, IMarginProps, IPickerProps, Omit<IDatePickerControlsProps, 'active'>, IDatePickerMonthProps, IDatePickerMonthsProps, IDatePickerYearsProps, IDatePickerHeaderProps {
     modelValue?: string | Date | Array<string | Date>;
 }
@@ -10,3 +10,20 @@ export interface IDatePickerEmits extends ICommonsComponentEmits {
     (e: 'update:year', value: number): void;
     (e: 'update:viewMode', value: TDateMode): void;
 }
+/** Scope forwarded on the `header` slot — the computed header text plus the
+ *  reverse-aware transition wrapper (`OrigamTranslatePicker` /
+ *  `OrigamReverseTranslatePicker`) driving its enter/leave direction. */
+export interface IDatePickerHeaderSlot {
+    header: string;
+    transition: TTransitionProps;
+}
+/** Slot signatures for `<OrigamDatePicker>`. `title` / `default` / `actions`
+ *  render with no scope (the default render swaps controls + month/months/
+ *  years panels internally); `header` forwards `<OrigamDatePickerHeader>`'s
+ *  computed text + transition so a custom render can reuse them. */
+export interface IDatePickerSlots {
+    title?: () => any;
+    header?: (props: IDatePickerHeaderSlot) => any;
+    default?: () => any;
+    actions?: () => any;
+}

package/dist/src/interfaces/DatePickerField/date-picker-field.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IChipProps, IMenuProps, ITextFieldProps, ITransitionComponentProps } from "../../interfaces";
+import type { IAdjacentSlots, IChipProps, IFieldSlots, IMenuProps, ITextFieldProps, ITransitionComponentProps } from "../../interfaces";
 export interface IDatePickerFieldProps extends ITextFieldProps, ITransitionComponentProps {
     menu?: boolean;
     menuProps?: IMenuProps;
@@ -11,3 +11,19 @@ export interface IDatePickerFieldProps extends ITextFieldProps, ITransitionCompo
     chipProps?: IChipProps;
     closableChips?: boolean;
 }
+/** Slot signatures for `<OrigamDatePickerField>` — the field chrome
+ *  slots (`IFieldSlots` minus its scoped `default`, since this field
+ *  renders its own selection markup instead) plus `prepend` / `append`
+ *  (`IAdjacentSlots`) and the date-selection overrides. */
+export interface IDatePickerFieldSlots extends Omit<IFieldSlots, 'default'>, IAdjacentSlots {
+    /** Overrides the formatted range text (`range` mode, single-select display). */
+    rangeSelection?: () => any;
+    /** Overrides one selected-date chip (`multiple` mode). */
+    chip?: (data: {
+        item: string;
+        index: number;
+        props: Record<string, unknown>;
+    }) => any;
+    /** Overrides a single selected-date's text representation. */
+    selection?: () => any;
+}

package/dist/src/interfaces/Dialog/dialog-confirmation.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IDialogProps } from '../../interfaces';
+import type { IDialogProps, IDialogSlots } from '../../interfaces';
 export interface IDialogConfirmationProps extends IDialogProps {
     cancellable?: boolean;
 }
@@ -7,3 +7,11 @@ export interface IDialogConfirmationEmits {
     (e: 'validate', event?: MouseEvent): void;
     (e: 'cancel', event?: MouseEvent): void;
 }
+/** Slot signatures for `<OrigamDialogConfirmation>` — same chrome slots
+ *  as `<OrigamDialog>`, but `default` and `header-title` are forwarded
+ *  unscoped here (the template does `<slot name="…"/>` with no
+ *  `v-bind`, unlike `<OrigamDialog>`'s own versions of those slots). */
+export interface IDialogConfirmationSlots extends Omit<IDialogSlots, 'default' | 'header-title'> {
+    default?: () => any;
+    'header-title'?: () => any;
+}

package/dist/src/interfaces/Dialog/dialog.interface.d.ts

@@ -13,3 +13,30 @@ export interface IDialogProps extends ICommonsComponentProps, IOverlayProps, ICa
 export interface IDialogEmits extends ICommonsComponentEmits, IClickOutsideEmits {
     (e: 'isRead', value: boolean): void;
 }
+/** Slot signatures for `<OrigamDialog>` — the inner `<OrigamOverlay>`'s
+ *  `default` scope, plus the `<OrigamCard>` chrome slots re-exposed
+ *  under Dialog's own (hyphenated) slot names. `activator` only
+ *  forwards the merged `props` bag, not the overlay's `isActive` —
+ *  matches the template's `v-bind="{props}"` (destructured from
+ *  `#activator="{props}"`). */
+export interface IDialogSlots {
+    activator?: (data: {
+        props: Record<string, unknown>;
+    }) => any;
+    default?: (data: {
+        isActive: boolean;
+    }) => any;
+    loader?: () => any;
+    header?: () => any;
+    'header-append'?: () => any;
+    'header-prepend'?: () => any;
+    'header-title'?: (data: {
+        titleId: string;
+    }) => any;
+    'header-subtitle'?: () => any;
+    'header-content'?: () => any;
+    asset?: () => any;
+    text?: () => any;
+    content?: () => any;
+    footer?: () => any;
+}

package/dist/src/interfaces/Drawer/drawer.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IActiveProps, IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IHoverProps, ILayoutItemProps, IMarginProps, IPaddingProps, IRoundedProps, IScrimProps, ITagProps, ITransitionComponentProps } from '../../interfaces';
+import type { IActiveProps, IAdjacentSlots, IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IHoverProps, ILayoutItemProps, IMarginProps, IPaddingProps, IRoundedProps, IScrimProps, ITagProps, ITransitionComponentProps } from '../../interfaces';
 export interface IDrawerProps extends ITagProps, ICommonsComponentProps, IBorderProps, IElevationProps, ILayoutItemProps, IRoundedProps, IColorProps, IBgColorProps, IDensityProps, IPaddingProps, IMarginProps, ITransitionComponentProps, IScrimProps, IActiveProps, IHoverProps {
     disableResizeWatcher?: boolean;
     disableRouteWatcher?: boolean;
@@ -52,3 +52,9 @@ export interface IDrawerProps extends ITagProps, ICommonsComponentProps, IBorder
 export interface IDrawerEmits {
     (e: 'update:rail', value: boolean): void;
 }
+/** Slot signatures for `<OrigamDrawer>`. */
+export interface IDrawerSlots extends IAdjacentSlots {
+    /** Overrides the whole prepend/content/append layout. */
+    wrapper?: () => any;
+    default?: () => any;
+}

package/dist/src/interfaces/ExpensionPanel/expansion-panel-content.interface.d.ts

@@ -3,3 +3,8 @@ import type { IBorderProps, IBgColorProps, IColorProps, ICommonsComponentProps,
 export interface IExpansionPanelContentProps extends IColorProps, IBgColorProps, ITagProps, ICommonsComponentProps, IDensityProps, IRoundedProps, IBorderProps, IPaddingProps, IMarginProps, ILazyProps, ILoaderProps {
     content?: string | Component;
 }
+/** Slot signatures for `<OrigamExpansionPanelContent>`. */
+export interface IExpansionPanelContentSlots {
+    loader?: () => any;
+    default?: () => any;
+}

package/dist/src/interfaces/ExpensionPanel/expansion-panel-header.interface.d.ts

@@ -12,3 +12,22 @@ export interface IExpansionPanelHeaderProps extends IColorProps, IBgColorProps,
 /** Emits fired by `<OrigamExpansionPanelHeader>` — prepend/append icon clicks. */
 export interface IExpansionPanelHeaderEmits extends IAdjacentEmits {
 }
+/** Scope forwarded to every `<OrigamExpansionPanelHeader>` slot — the
+ *  panel's current expand/disabled/readonly state plus the resolved
+ *  expand/collapse icons. */
+export interface IExpansionPanelHeaderSlotProps {
+    collapseIcon?: TIcon;
+    disabled?: boolean;
+    expanded: boolean;
+    expandIcon?: TIcon;
+    readonly?: boolean;
+}
+/** Slot signatures for `<OrigamExpansionPanelHeader>`. `prepend` /
+ *  `append` receive the same scope as `title` / `default` here (NOT
+ *  the unscoped `IAdjacentSlots` shape used elsewhere in the DS). */
+export interface IExpansionPanelHeaderSlots {
+    prepend?: (data: IExpansionPanelHeaderSlotProps) => any;
+    title?: (data: IExpansionPanelHeaderSlotProps) => any;
+    default?: (data: IExpansionPanelHeaderSlotProps) => any;
+    append?: (data: IExpansionPanelHeaderSlotProps) => any;
+}

package/dist/src/interfaces/ExpensionPanel/expansion-panel.interface.d.ts

@@ -1,6 +1,20 @@
-import type { IActiveProps, IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IExpansionPanelContentProps, IExpansionPanelHeaderProps, IGroupEmits, IGroupItemProps, IHoverProps, ILazyProps, ILoaderProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
+import type { IActiveProps, IBgColorProps, IBorderProps, IColorProps, ICommonsComponentProps, IDensityProps, IElevationProps, IExpansionPanelContentProps, IExpansionPanelHeaderProps, IExpansionPanelHeaderSlotProps, IGroupEmits, IGroupItemProps, IHoverProps, ILazyProps, ILoaderProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
 export interface IExpansionPanelProps extends ITagProps, ICommonsComponentProps, IDensityProps, IColorProps, IBgColorProps, IBorderProps, IPaddingProps, IMarginProps, IElevationProps, IRoundedProps, IGroupItemProps, IExpansionPanelHeaderProps, IExpansionPanelContentProps, ILazyProps, ILoaderProps, IActiveProps, IHoverProps {
 }
 /** Emits fired by `<OrigamExpansionPanel>` — group membership lifecycle. */
 export interface IExpansionPanelEmits extends IGroupEmits {
 }
+/** Slot signatures for `<OrigamExpansionPanel>`. `header` / `wrapper`
+ *  receive the filtered props forwarded to the nested
+ *  `<OrigamExpansionPanelHeader>` / `<OrigamExpansionPanelContent>`;
+ *  `prepend` / `title` / `append` receive that header's own slot scope
+ *  (they're forwarded straight through to it). */
+export interface IExpansionPanelSlots {
+    loader?: () => any;
+    header?: (props: Partial<IExpansionPanelHeaderProps>) => any;
+    prepend?: (data: IExpansionPanelHeaderSlotProps) => any;
+    title?: (data: IExpansionPanelHeaderSlotProps) => any;
+    append?: (data: IExpansionPanelHeaderSlotProps) => any;
+    wrapper?: (props: Partial<IExpansionPanelContentProps>) => any;
+    default?: () => any;
+}

package/dist/src/interfaces/ExpensionPanel/expansion-panels.interface.d.ts

@@ -1,4 +1,4 @@
-import type { IActiveProps, IBgColorProps, IBorderProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IExpansionPanelProps, IGroupProps, IHoverProps, ILazyProps, ILoaderProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
+import type { IActiveProps, IBgColorProps, IBorderProps, IColorProps, ICommonsComponentEmits, ICommonsComponentProps, IDensityProps, IElevationProps, IExpansionPanelContentProps, IExpansionPanelHeaderProps, IExpansionPanelHeaderSlotProps, IExpansionPanelProps, IGroupProps, IHoverProps, ILazyProps, ILoaderProps, IMarginProps, IPaddingProps, IRoundedProps, ITagProps } from '../../interfaces';
 import type { TIcon } from '../../types';
 export interface IExpansionPanelsProps extends IColorProps, IBgColorProps, ITagProps, ICommonsComponentProps, IGroupProps, IDensityProps, IRoundedProps, IBorderProps, IPaddingProps, IMarginProps, ILazyProps, ILoaderProps, IElevationProps, IActiveProps, IHoverProps {
     flat?: boolean;
@@ -13,3 +13,37 @@ export interface IExpansionPanelsProps extends IColorProps, IBgColorProps, ITagP
 /** Emits fired by `<OrigamExpansionPanels>` — v-model on the active panel set. */
 export interface IExpansionPanelsEmits extends ICommonsComponentEmits {
 }
+/** Scope forwarded to the per-item `item.{index}` / `item` slots. */
+export interface IExpansionPanelsItemSlotProps {
+    collapseIcon?: TIcon;
+    expandIcon?: TIcon;
+    hideActions?: boolean;
+    item: IExpansionPanelProps;
+    index: number;
+}
+/**
+ * Slot signatures for `<OrigamExpansionPanels>`.
+ *
+ * Per-panel overrides are only known at runtime (`item-{index}` and the
+ * per-panel `header` / `prepend` / `title` / `append` / `wrapper` /
+ * `content` forwards), so they're expressed as template-literal index
+ * signatures alongside the un-indexed fallback names the template also
+ * checks (`slots[\`header.${index}\`] || slots.header`, …).
+ */
+export interface IExpansionPanelsSlots {
+    default?: () => any;
+    item?: (data: IExpansionPanelsItemSlotProps) => any;
+    header?: (props: Partial<IExpansionPanelHeaderProps>) => any;
+    prepend?: (data: IExpansionPanelHeaderSlotProps) => any;
+    title?: (data: IExpansionPanelHeaderSlotProps) => any;
+    append?: (data: IExpansionPanelHeaderSlotProps) => any;
+    wrapper?: (props: Partial<IExpansionPanelContentProps>) => any;
+    content?: () => any;
+    [key: `item.${number}`]: ((data: IExpansionPanelsItemSlotProps) => any) | undefined;
+    [key: `header.${number}`]: ((props: Partial<IExpansionPanelHeaderProps>) => any) | undefined;
+    [key: `prepend.${number}`]: ((data: IExpansionPanelHeaderSlotProps) => any) | undefined;
+    [key: `title.${number}`]: ((data: IExpansionPanelHeaderSlotProps) => any) | undefined;
+    [key: `append.${number}`]: ((data: IExpansionPanelHeaderSlotProps) => any) | undefined;
+    [key: `wrapper.${number}`]: ((props: Partial<IExpansionPanelContentProps>) => any) | undefined;
+    [key: `content.${number}`]: (() => any) | undefined;
+}

package/dist/src/interfaces/Icon/icon.interface.d.ts

@@ -6,6 +6,11 @@ export interface IIconProps {
 export interface IIconComponentProps extends IIconProps, IColorProps, IBgColorProps, ICommonsComponentProps, ITagProps, ISizeProps, IPaddingProps, IMarginProps, IBorderProps, IDimensionProps, IRoundedProps {
     disabled?: boolean;
 }
+/** Slot signatures shared by `<OrigamIcon>` and `<OrigamComponentIcon>` —
+ *  a single unscoped `default` slot holding the icon glyph / fallback. */
+export interface IIconComponentSlots {
+    default?: () => any;
+}
 export interface IIconAliases {
     [name: string]: TIcon;
 }

package/dist/src/interfaces/Img/img.interface.d.ts

@@ -35,3 +35,9 @@ export interface IImgEmits {
         src: string;
     }): void;
 }
+/** Slot signatures for `<OrigamImg>`. */
+export interface IImgSlots {
+    placeholder?: () => any;
+    error?: () => any;
+    default?: () => any;
+}

package/dist/src/interfaces/InfiniteScroll/infinite-scroll.interface.d.ts

@@ -1,5 +1,5 @@
 import type { IBgColorProps, IColorProps, ICommonsComponentProps, IDimensionProps, IDirectionProps, ITagProps, ITypographyProps } from '../../interfaces';
-import type { TInfiniteScrollMode, TInfiniteScrollSide } from '../../types';
+import type { TColor, TInfiniteScrollMode, TInfiniteScrollSide } from '../../types';
 export interface IInfiniteScrollProps extends ICommonsComponentProps, IColorProps, IBgColorProps, IDimensionProps, ITagProps, IDirectionProps, ITypographyProps {
     side?: TInfiniteScrollSide;
     mode?: TInfiniteScrollMode;
@@ -28,3 +28,21 @@ export interface IInfiniteScrollIntersectEmits {
         side: TInfiniteScrollSide;
     }): void;
 }
+/** Scope forwarded to every `<OrigamInfiniteScroll>` side slot
+ *  (`error` / `empty` / `loading` / `loadMore`) — which edge triggered
+ *  it, plus a ready-to-bind click handler + the resolved color. */
+export interface IInfiniteScrollSideSlotProps {
+    side: TInfiniteScrollSide;
+    props: {
+        onClick: () => void;
+        color: TColor | undefined;
+    };
+}
+/** Slot signatures for `<OrigamInfiniteScroll>`. */
+export interface IInfiniteScrollSlots {
+    error?: (data: IInfiniteScrollSideSlotProps) => any;
+    empty?: (data: IInfiniteScrollSideSlotProps) => any;
+    loading?: (data: IInfiniteScrollSideSlotProps) => any;
+    loadMore?: (data: IInfiniteScrollSideSlotProps) => any;
+    default?: () => any;
+}

package/dist/src/interfaces/ItemGroup/item-group.interface.d.ts

@@ -1,4 +1,4 @@
-import type { ICommonsComponentEmits, ICommonsComponentProps, IGroupItemProps, IGroupProps, ITagProps } from '../../interfaces';
+import type { ICommonsComponentEmits, ICommonsComponentProps, IGroupItemProps, IGroupProps, IGroupProvide, ITagProps } from '../../interfaces';
 /**
  * Props for `<OrigamItemGroup>` — the renderless selection container.
  * Mirrors `IBtnToggleProps` minus the visual mixins (this group has
@@ -27,3 +27,23 @@ export interface IItemGroupItemProps extends ICommonsComponentProps, ITagProps,
 /** Emits fired by `<OrigamItemGroup>` — v-model on the active item set. */
 export interface IItemGroupEmits extends ICommonsComponentEmits {
 }
+/** Scope forwarded to `<OrigamItem>`'s `default` slot — the resolved
+ *  selection state from the enclosing `<OrigamItemGroup>`. */
+export interface IItemGroupItemSlotProps {
+    isSelected: boolean;
+    selectedClass: Array<string | undefined> | false;
+    toggle: () => void;
+    select: (value: boolean) => void;
+    value: unknown;
+    disabled: boolean | undefined;
+}
+/** Slot signatures for `<OrigamItem>`. */
+export interface IItemGroupItemSlots {
+    default?: (data: IItemGroupItemSlotProps) => any;
+}
+/** Slot signatures for `<OrigamItemGroup>` — the raw `useGroup()`
+ *  selection API, forwarded as-is (its `selected` field stays a `Ref`,
+ *  unlike `OrigamItem`'s own unwrapped `default` scope). */
+export interface IItemGroupSlots {
+    default?: (data: Pick<IGroupProvide, 'isSelected' | 'select' | 'next' | 'prev' | 'selected'>) => any;
+}

package/dist/src/interfaces/Kbd/kbd.interface.d.ts

@@ -10,3 +10,8 @@ export interface IKbdProps extends ICommonsComponentProps, IColorProps, IBgColor
     /** Visual variant. Defaults to 'outlined'. */
     variant?: TKbdVariant;
 }
+/** Slot signatures for `<OrigamKbd>`. The default slot wins over both
+ *  the `combination` and `text` props. */
+export interface IKbdSlots {
+    default?: () => any;
+}

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

@@ -1,3 +1,4 @@
+import type { IListGroupActivatorSlotProps } from '../../interfaces';
 import type { TListItemType } from '../../types';
 export interface IListItemChildren {
     items: Array<IInternalListItemChildren>;
@@ -19,3 +20,30 @@ export interface IInternalItem<T = any> {
     value?: any;
     raw: T;
 }
+/** Slot signatures for `<OrigamListChildren>`. `divider` / `subheader` /
+ *  `group` / `item` all forward the same `{ itemProps }` shape — the
+ *  resolved item's `props` bag, spread onto whichever DS component
+ *  renders that row. */
+export interface IListChildrenSlots<T = any> {
+    default?: () => any;
+    children?: (data: {
+        item: IInternalListItemChildren<T>;
+        index: number;
+    }) => any;
+    divider?: (data: {
+        itemProps: IInternalListItem<T>['props'];
+    }) => any;
+    subheader?: (data: {
+        itemProps: IInternalListItem<T>['props'];
+    }) => any;
+    subheaderTitle?: (data: {
+        title?: string;
+    }) => any;
+    group?: (data: {
+        itemProps: IInternalListItem<T>['props'];
+    }) => any;
+    groupActivator?: (data: IListGroupActivatorSlotProps) => any;
+    item?: (data: {
+        itemProps: IInternalListItem<T>['props'];
+    }) => any;
+}