origam 2.14.1 → 2.16.0

package/dist/src/types/Chart/chart-sankey.type.d.ts

@@ -0,0 +1,21 @@
+import { OrigamChartSankey } from '../../components';
+export type TOrigamChartSankey = InstanceType<typeof OrigamChartSankey>;
+/**
+ * Per-link layout spec computed while laying out ribbons — carries the
+ * source/target band heights and Y offsets used to sort links so
+ * ribbons leave each source in target-Y order and arrive at each
+ * target in source-Y order. Moved out of `OrigamChartSankey.vue` (was
+ * a `type` declared inside the `layoutLinks` computed) so the `.vue`
+ * file only imports it, per the "no declarations in .vue" rule.
+ */
+export type TChartSankeyLinkSpec = {
+    index: number;
+    from: string;
+    to: string;
+    value: number;
+    color: string;
+    srcBandH: number;
+    tgtBandH: number;
+    srcY: number;
+    tgtY: number;
+};

package/dist/src/types/Chart/{chart-sparkline-kind.type.d.ts → chart-sparkline.type.d.ts}

@@ -1,4 +1,5 @@
 import { CHART_SPARKLINE_KIND } from '../../enums';
+import { OrigamChartSparkline } from '../../components';
 /**
  * The four rendering modes of the sparkline family.
  *
@@ -8,3 +9,4 @@ import { CHART_SPARKLINE_KIND } from '../../enums';
  * - `'bar'`    — horizontal bars (Y values mapped to width).
  */
 export type TChartSparklineKind = `${CHART_SPARKLINE_KIND}`;
+export type TOrigamChartSparkline = InstanceType<typeof OrigamChartSparkline>;

package/dist/src/types/Chart/chart-streamgraph.type.d.ts

@@ -0,0 +1,4 @@
+import { OrigamChartStreamgraph } from '../../components';
+import { CHART_STREAMGRAPH_OFFSET } from '../../enums';
+export type TChartStreamgraphOffset = `${CHART_STREAMGRAPH_OFFSET}`;
+export type TOrigamChartStreamgraph = InstanceType<typeof OrigamChartStreamgraph>;

package/dist/src/types/Chart/chart-sunburst.type.d.ts

@@ -0,0 +1,10 @@
+import { OrigamChartSunburst } from '../../components';
+import { CHART_SUNBURST_LABEL_MODE } from '../../enums';
+export type TOrigamChartSunburst = InstanceType<typeof OrigamChartSunburst>;
+/**
+ * How the label for a node is rendered.
+ * - `'inline'`  — centred horizontally inside the arc (wide arcs).
+ * - `'rotated'` — rotated tangentially along the arc midpoint (narrow arcs).
+ * - `'leader'`  — placed outside the chart with a leader line (very narrow arcs).
+ */
+export type TChartSunburstLabelMode = `${CHART_SUNBURST_LABEL_MODE}`;

package/dist/src/types/Chart/chart-tooltip.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamChartTooltip } from '../../components';
+export type TOrigamChartTooltip = InstanceType<typeof OrigamChartTooltip>;

package/dist/src/types/Chart/{chart-treemap-algorithm.type.d.ts → chart-treemap.type.d.ts}

@@ -1,3 +1,5 @@
+import { OrigamChartTreemap } from '../../components';
+import { CHART_TREEMAP_ALGORITHM } from '../../enums';
 /**
  * Treemap layout algorithm selector.
  *
@@ -9,4 +11,5 @@
  *   each recursion level (slice at even depth, dice at odd depth).
  *   Tiles tend to be long and thin but preserve data order.
  */
-export type TChartTreemapAlgorithm = 'squarified' | 'slice-dice';
+export type TChartTreemapAlgorithm = `${CHART_TREEMAP_ALGORITHM}`;
+export type TOrigamChartTreemap = InstanceType<typeof OrigamChartTreemap>;

package/dist/src/types/Chart/chart-variwide.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamChartVariwide } from '../../components';
+export type TOrigamChartVariwide = InstanceType<typeof OrigamChartVariwide>;

package/dist/src/types/Chart/chart-word-cloud.type.d.ts

@@ -0,0 +1,21 @@
+import { CHART_WORD_CLOUD_ROTATION } from '../../enums/Chart/chart-word-cloud.enum';
+import { OrigamChartWordCloud } from '../../components';
+/**
+ * Word rotation mode for `<OrigamChartWordCloud>`.
+ * - `'none'`        — all words horizontal (0°).
+ * - `'random'`      — uniform random angle in [-30°, 30°].
+ * - `'orthogonal'`  — each word either 0° or 90° (parity-based for determinism).
+ */
+export type TChartWordCloudRotation = `${CHART_WORD_CLOUD_ROTATION}`;
+export type TOrigamChartWordCloud = InstanceType<typeof OrigamChartWordCloud>;
+/**
+ * Raw datum shape accepted from `series[0].data` before placement.
+ * Moved out of `OrigamChartWordCloud.vue` (was a `type` declared
+ * inside the `placedWords` computed) so the `.vue` file only imports
+ * it, per the "no declarations in .vue" rule.
+ */
+export type TChartWordCloudRawDatum = {
+    text: string;
+    value: number;
+    color?: string;
+};

package/dist/src/types/Chart/chart.type.d.ts

@@ -0,0 +1,56 @@
+import type { CHART_STACKING } from '../../enums';
+import { CHART_SMOOTHING, CHART_TYPE } from '../../enums';
+import { OrigamChart } from '../../components';
+/**
+ * Loose item shape accepted by chart data arrays — either a raw
+ * primitive (string label / number value) or a `{ value }` object
+ * for richer descriptors. Consumers normalise via
+ * `IChartSeries.data` / `useChart`.
+ */
+export type TChartItem = string | number | {
+    value: number;
+};
+/**
+ * Path smoothing strategy for `line` / `area` / `spline` charts.
+ *
+ * - `'none'`     — straight line segments between data points (default).
+ * - `'curve'`    — cubic Bezier between every pair of points using a
+ *                  tangent estimation a la Catmull-Rom. Visually
+ *                  smoother but slightly overshoots at sharp peaks.
+ * - `'monotone'` — monotone cubic interpolation (Fritsch-Carlson).
+ *                  Smooth like `'curve'` but guaranteed not to
+ *                  overshoot — what most "spline" demos show. Used
+ *                  as the implicit default for `type='spline'`.
+ *
+ * Note: `'stepped-line'` is a CHART_TYPE, not a smoothing value —
+ * staircase is a different topology (right-angle connections),
+ * not a curve choice. See `TChartCartesianKind`.
+ */
+export type TChartSmoothing = `${CHART_SMOOTHING}`;
+/**
+ * Stacking strategy for bar / column / area charts.
+ *
+ * - `'normal'`  — raw absolute values stacked on top of each other.
+ * - `'percent'` — each stack normalised to 100 %; Y-axis fixed
+ *                 `0 → 100`, tick labels show `${v}%`.
+ */
+export type TChartStacking = `${CHART_STACKING}`;
+/**
+ * Union of all visualisation primitives accepted by the chart family.
+ * Derives from `CHART_TYPE` so the enum stays the single source of
+ * truth.
+ */
+export type TChartType = `${CHART_TYPE}`;
+export type TOrigamChart = InstanceType<typeof OrigamChart>;
+/**
+ * A pre-scaled `[x, y]` coordinate pair (pixels in the SVG viewBox),
+ * as consumed by the path builders in `src/utils/Chart/path.util.ts`.
+ *
+ * Deliberately a TUPLE, not the object-shaped `TPoint` (`{ x, y }`)
+ * from `types/Commons/point.type.ts`: the path helpers build strings
+ * from long lists of coordinates on every render, and the tuple form
+ * both destructures positionally (`const [x, y] = p`) and keeps the
+ * call sites readable (`linePath([[0, 0], [10, 10]])`). The two are not
+ * interchangeable and neither replaces the other.
+ */
+export type TPathPoint = [number, number];

package/dist/src/types/ClientOnly/client-only.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamClientOnly } from '../../components';
+export type TOrigamClientOnly = InstanceType<typeof OrigamClientOnly>;

package/dist/src/types/Clipboard/clipboard.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamClipboard } from '../../components';
+export type TOrigamClipboard = InstanceType<typeof OrigamClipboard>;

package/dist/src/types/Code/code.type.d.ts

@@ -0,0 +1,24 @@
+import { CODE_LANG, CODE_THEME } from '../../enums';
+import { OrigamCode } from '../../components';
+export type TOrigamCode = InstanceType<typeof OrigamCode>;
+export type TCodeLang = `${CODE_LANG}`;
+export type TCodeTheme = `${CODE_THEME}`;
+/**
+ * The slice of shiki's highlighter API that `useCode()` actually calls.
+ *
+ * `shiki` is an OPTIONAL peer dependency, so the DS must not `import
+ * type` from it — that would make shiki's own types a hard build
+ * requirement for every consumer, including those who never install it.
+ * Declaring the one method we use keeps the dynamic-import fallback
+ * path type-safe with zero dependency on the package being present.
+ */
+export type TShikiHighlighter = {
+    codeToHtml: (code: string, opts: {
+        lang: string;
+        themes?: {
+            light: string;
+            dark: string;
+        };
+        defaultColor?: false | string;
+    }) => string;
+};

package/dist/src/types/ColorPickerField/color-picker-field.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamColorPickerField } from '../../components';
+export type TOrigamColorPickerField = InstanceType<typeof OrigamColorPickerField>;

package/dist/src/types/CommandPalette/{command-palette-hotkey.type.d.ts → command-palette.type.d.ts}

@@ -1,3 +1,5 @@
+import { OrigamCommandPalette } from '../../components';
+export type TOrigamCommandPalette = InstanceType<typeof OrigamCommandPalette>;
 /**
  * A normalised hotkey combination — array of canonical key tokens
  * accepted by `useHotkey` (e.g. `['meta', 'k']`).

package/dist/src/types/Commons/align.type.d.ts

@@ -1,2 +1,7 @@
-import { ALIGN } from '../../enums';
+import { ALIGN, TEXT_ALIGN } from '../../enums';
 export type TAlign = `${ALIGN}`;
+/**
+ * Physical text alignment (`text-align`). See {@link TAlign} for the
+ * logical box-alignment vocabulary — the two are distinct on purpose.
+ */
+export type TTextAlign = `${TEXT_ALIGN}`;

package/dist/src/types/Commons/border.type.d.ts

@@ -1,2 +1,12 @@
-import { BORDER_STYLE } from '../../enums';
+import { BORDER_LOGICAL_AXIS, BORDER_STYLE } from '../../enums';
 export type TBorderStyle = `${BORDER_STYLE}`;
+/**
+ * CSS logical border axes (`border-block` / `border-inline`), as opposed
+ * to the PHYSICAL per-side directions (`TDirectionBoth` = top/bottom/
+ * left/right). Used to drive `borderBlock` / `borderInline` on
+ * `IBorderProps` — these resolve to the native CSS logical properties
+ * `border-block-*` / `border-inline-*`, which the browser itself maps to
+ * the correct physical edges per the current writing mode (no manual
+ * LTR/RTL translation needed on our side).
+ */
+export type TBorderLogicalAxis = `${BORDER_LOGICAL_AXIS}`;

package/dist/src/types/Commons/color.type.d.ts

@@ -1,3 +1,4 @@
+import { BG_FG_ROLE } from '../../enums';
 import type { IGradient } from '../../interfaces/Commons/gradient.interface';
 /**
  * Accepted shapes for the `color` / `bgColor` / `textColor` props.
@@ -51,4 +52,4 @@ export type TColorType = string | number | THSVA | TRGBA | THSLA;
  *   • `active`   → cascading `var(bgActive, color-mix(bg, black 30%))`
  *   • `disabled` → resting `bgDisabled` token (per-intent)
  */
-export type TBgFgRole = 'default' | 'hover' | 'active' | 'disabled';
+export type TBgFgRole = `${BG_FG_ROLE}`;

package/dist/src/types/Commons/controls.type.d.ts

@@ -0,0 +1,2 @@
+import { CONTROLS_SOURCE } from '../../enums';
+export type TControlsSource = `${CONTROLS_SOURCE}`;

package/dist/src/types/Commons/css-support.type.d.ts

@@ -0,0 +1,26 @@
+import { FEATURE_QUERIES } from '../../consts/CssSupport/css-support.const';
+/**
+ * Name of a feature in the monitored CSS support matrix.
+ *
+ * Derived from `FEATURE_QUERIES` rather than restated, so adding an
+ * entry to that `as const satisfies` literal is the single edit needed
+ * to widen the matrix — the type follows automatically.
+ *
+ * FILED UNDER `Commons/`, NOT `CssSupport/`
+ * ----------------------------------------
+ * `useCssSupport()` is the DS's single feature-detection layer, consumed
+ * across the catalogue to pick a CSS-first path over a JS fallback — it
+ * is a cross-cutting subsystem, not a component's prop surface, which is
+ * exactly what `types/Commons/` is for (and why the `file-naming` guard
+ * exempts that directory: a file there is deliberately not tied to one
+ * component, and no `OrigamCssSupport` exists to name it after).
+ *
+ * The matching `FEATURE_QUERIES` const sits in `consts/CssSupport/`
+ * under its own documented exemption in the same guard. Sibling
+ * directories would have been more symmetrical, but that needs the
+ * guard's `exemptDirs` widened to `types/CssSupport` — a guard change,
+ * which is a lead's call, not a side effect of moving a type.
+ */
+export type TCssFeatureName = keyof typeof FEATURE_QUERIES;
+/** Snapshot of the whole matrix: every feature name → supported or not. */
+export type TCssSupportMap = Readonly<Record<TCssFeatureName, boolean>>;

package/dist/src/types/Commons/font-family.type.d.ts

@@ -1,5 +1,6 @@
+import { FONT_FAMILY } from '../../enums';
 /**
  * Font-family token keys (map to `--origam-font__family---{key}`):
  *   sans (Inter / Helvetica Neue / Arial) · mono (JetBrains Mono / Fira Code) · serif (Georgia / Times New Roman)
  */
-export type TFontFamily = 'sans' | 'mono' | 'serif';
+export type TFontFamily = `${FONT_FAMILY}`;

package/dist/src/types/Commons/font-size.type.d.ts

@@ -1,6 +1,7 @@
+import { FONT_SIZE } from '../../enums';
 /**
  * Font-size token keys (map to `--origam-font__size---{key}`):
  *   xs 0.625rem · sm 0.75rem · md 0.875rem · lg 1rem · xl 1.125rem
  *   2xl 1.25rem · 3xl 1.5rem · 4xl 1.875rem · 5xl 2.25rem
  */
-export type TFontSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl';
+export type TFontSize = `${FONT_SIZE}`;

package/dist/src/types/Commons/font-weight.type.d.ts

@@ -1,5 +1,6 @@
+import { FONT_WEIGHT } from '../../enums';
 /**
  * Font-weight token keys (map to `--origam-font__weight---{key}`):
  *   regular 400 · medium 500 · semibold 600 · bold 700 · extrabold 800 · black 900
  */
-export type TFontWeight = 'regular' | 'medium' | 'semibold' | 'bold' | 'extrabold' | 'black';
+export type TFontWeight = `${FONT_WEIGHT}`;

package/dist/src/types/Commons/intent.type.d.ts

@@ -1,3 +1,4 @@
+import { INTENT } from '../../enums';
 /**
  * Semantic intents accepted by `useColorEffect` and `intent`-prop components
  * (Btn, Chip, Alert, Badge, …).
@@ -10,4 +11,4 @@
  * `--origam-{component}--{intent}---{prop}`
  * (e.g. `--origam-btn--success---bg`).
  */
-export type TIntent = 'neutral' | 'primary' | 'secondary' | 'ghost' | 'success' | 'warning' | 'danger' | 'info';
+export type TIntent = `${INTENT}`;

package/dist/src/types/Commons/letter-spacing.type.d.ts

@@ -1,5 +1,6 @@
+import { LETTER_SPACING } from '../../enums';
 /**
  * Letter-spacing token keys (map to `--origam-font__letterSpacing---{key}`):
  *   tight -0.025em · normal 0em · wide 0.0094em · wider 0.0125em · widest 0.0893em
  */
-export type TLetterSpacing = 'tight' | 'normal' | 'wide' | 'wider' | 'widest';
+export type TLetterSpacing = `${LETTER_SPACING}`;

package/dist/src/types/Commons/line-height.type.d.ts

@@ -1,5 +1,6 @@
+import { LINE_HEIGHT } from '../../enums';
 /**
  * Line-height token keys (map to `--origam-font__lineHeight---{key}`):
  *   none 1 · tight 1.25 · snug 1.375 · normal 1.5 · relaxed 1.625 · loose 2
  */
-export type TLineHeight = 'none' | 'tight' | 'snug' | 'normal' | 'relaxed' | 'loose';
+export type TLineHeight = `${LINE_HEIGHT}`;

package/dist/src/types/Commons/loader.type.d.ts

@@ -1,9 +1,10 @@
+import { LOADER_KIND } from '../../enums';
 import type { IProgressCircularProps, IProgressLinearProps, ISkeletonProps } from '../../interfaces';
 /**
  * Loader kind — decides which renderer is mounted by the consumer
  * component when a loading state is active.
  */
-export type TLoaderKind = 'line' | 'circular' | 'skeleton';
+export type TLoaderKind = `${LOADER_KIND}`;
 /**
  * Per-kind override config. Each kind extends the corresponding component's
  * Partial props so the consumer gets full IDE autocomplete for the right
@@ -15,11 +16,11 @@ export type TLoaderKind = 'line' | 'circular' | 'skeleton';
  * defensively.
  */
 export type TLoaderConfig = ({
-    type: 'line';
+    type: `${LOADER_KIND.LINE}`;
 } & Partial<IProgressLinearProps>) | ({
-    type: 'circular';
+    type: `${LOADER_KIND.CIRCULAR}`;
 } & Partial<IProgressCircularProps>) | ({
-    type: 'skeleton';
+    type: `${LOADER_KIND.SKELETON}`;
 } & Partial<ISkeletonProps>);
 /**
  * The full `loading` prop value accepted by every consumer component.

package/dist/src/types/Commons/rounded.type.d.ts

@@ -12,3 +12,15 @@ import { ROUNDED, ROUNDED_TOKEN } from '../../enums';
  * type-check and never surfaced in autocompletion.
  */
 export type TRounded = `${ROUNDED}` | `${ROUNDED_TOKEN}`;
+/**
+ * Standalone name for the token-rung half of `TRounded` — the
+ * abbreviated `none | xs | sm | md | lg | xl | full` vocabulary.
+ *
+ * Beyond radius, this abbreviated vocabulary is also the DS's generic
+ * "how big is this thing" naming convention (mirrors `TDirection`'s
+ * role for axis words): other component-scoped size scales that use
+ * the same abbreviations — not the same CSS property, just the same
+ * string vocabulary — derive their subset from this type instead of
+ * redeclaring the strings (e.g. `TGridGapSize`, `TEmptyStateSize`).
+ */
+export type TRoundedToken = `${ROUNDED_TOKEN}`;

package/dist/src/types/Commons/state-effect.type.d.ts

@@ -0,0 +1,30 @@
+import type { IBgColorProps, IColorProps } from '../../interfaces/Commons/color.interface';
+import type { IBorderProps } from '../../interfaces/Commons/border.interface';
+import type { IElevationProps } from '../../interfaces/Commons/elevation.interface';
+import type { IMarginProps } from '../../interfaces/Commons/margin.interface';
+import type { IPaddingProps } from '../../interfaces/Commons/padding.interface';
+import type { IRoundedProps } from '../../interfaces/Commons/rounded.interface';
+/**
+ * The prop bag `useStateEffect` reads from.
+ *
+ * It is deliberately an INTERSECTION of the existing Commons prop
+ * interfaces rather than a fresh list of properties: `useStateEffect`
+ * delegates each axis to the matching per-axis composable
+ * (`useBorder`, `useRounded`, `useElevation`, `usePadding`,
+ * `useMargin`, `useColor`), so its accepted input is by definition the
+ * union of what those composables accept. Restating the properties
+ * here would let the two drift the moment one of the Commons
+ * interfaces gains a prop.
+ *
+ * `gap` is the one axis with no Commons interface of its own — it is
+ * an ad-hoc flex/grid property that only a handful of layout
+ * components expose — so it is spelled inline.
+ *
+ * Sibling type: {@link IStateEffectConfig} in
+ * `src/interfaces/Commons/state-effect.interface.ts` describes the
+ * OVERRIDE object a consumer passes to `hover` / `active`. This type
+ * describes the RESTING props those overrides are layered on top of.
+ */
+export type TStateEffectProps = IColorProps & IBgColorProps & IBorderProps & IRoundedProps & IElevationProps & IPaddingProps & IMarginProps & {
+    gap?: boolean | number | string;
+};

package/dist/src/types/ConfirmWrapper/confirm-wrapper.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamConfirmWrapper } from '../../components';
+export type TOrigamConfirmWrapper = InstanceType<typeof OrigamConfirmWrapper>;

package/dist/src/types/DataList/data-list.type.d.ts

@@ -1,2 +1,18 @@
 import { OrigamDataList } from "../../components";
+import { DATA_LIST_MODE } from "../../enums";
 export type TOrigamDataList = InstanceType<typeof OrigamDataList>;
+/**
+ * Layout mode of `<OrigamDataList>`.
+ *
+ * - `"avatar"` (default, back-compat) — the historical `<dl>` layout
+ *   where each item stacks a `<dt>` (title) above one or more `<dd>`
+ *   rows (text). Items conform to {@link IDataItem}. The naming reflects
+ *   the most common usage: a `prependAvatar` per title, with a stack of
+ *   labels below — the Vuetify `v-list`-flavoured shape.
+ *
+ * - `"kv"` — the PDF-aligned key/value table where each row renders a
+ *   key on the left (muted) and a value on the right (primary text or
+ *   an inline component such as `<origam-chip>` / `<origam-avatar>`).
+ *   Items conform to {@link IDataListKVItem}.
+ */
+export type TDataListMode = `${DATA_LIST_MODE}`;

package/dist/src/types/DefaultsProvider/defaults-provider.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamDefaultsProvider } from '../../components';
+export type TOrigamDefaultsProvider = InstanceType<typeof OrigamDefaultsProvider>;

package/dist/src/types/EmptyState/empty-state.type.d.ts

@@ -0,0 +1,46 @@
+import { OrigamEmptyState } from '../../components';
+import { EMPTY_STATE_PRESET } from '../../enums';
+import type { TTextAlign } from '../Commons/align.type';
+import type { TRoundedToken } from '../Commons/rounded.type';
+export type TOrigamEmptyState = InstanceType<typeof OrigamEmptyState>;
+/**
+ * Visual presets for `<OrigamEmptyState>`. Each preset bundles a
+ * default icon + intent mapping so consumers do not need to wire those
+ * by hand for the 95% case. The icon and intent can still be
+ * overridden via the matching props when a one-off variation is
+ * needed.
+ *
+ * - `no-data`     — generic "nothing to show yet" (empty collection).
+ * - `no-results`  — search or filter returned nothing.
+ * - `error`       — an operation failed; retry CTA is typical.
+ * - `offline`     — connectivity issue; offline-mode CTA is typical.
+ * - `locked`      — feature is gated (auth, plan, permissions).
+ */
+export type TEmptyStatePreset = `${EMPTY_STATE_PRESET}`;
+/**
+ * Horizontal alignment of the icon / title / description / actions
+ * stack inside `<OrigamEmptyState>`.
+ *
+ * - `center` — default. Centred stack, content also `text-align: center`.
+ *              Best for full-page or full-section placeholders.
+ * - `left`   — left-aligned stack. Best for narrow side panels or list
+ *              empty zones where the surrounding content is left-aligned.
+ *
+ * Narrows the Commons `TTextAlign` vocabulary rather than redeclaring
+ * the strings — `right` is excluded on purpose (no design token drives
+ * a right-aligned empty state).
+ */
+export type TEmptyStateAlign = Exclude<TTextAlign, 'right'>;
+/**
+ * Vertical density of `<OrigamEmptyState>`. Drives icon size + title /
+ * description font sizes + gap + padding via per-size token overrides.
+ *
+ * - `sm` — compact (inline empty zones inside dense containers).
+ * - `md` — default (full-page-section empty states).
+ * - `lg` — generous (hero empty pages, marketing-style placeholders).
+ *
+ * Reuses the Commons abbreviated size vocabulary (`TRoundedToken`, see
+ * `Commons/rounded.type.ts`) rather than redeclaring the strings —
+ * same naming convention, unrelated CSS property.
+ */
+export type TEmptyStateSize = Extract<TRoundedToken, 'sm' | 'md' | 'lg'>;

package/dist/src/types/FileField/file-field-drag-n-drop-item.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamFileFieldDragNDropItem } from '../../components';
+export type TOrigamFileFieldDragNDropItem = InstanceType<typeof OrigamFileFieldDragNDropItem>;

package/dist/src/types/FileField/file-field-list-item.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamFileFieldListItem } from '../../components';
+export type TOrigamFileFieldListItem = InstanceType<typeof OrigamFileFieldListItem>;

package/dist/src/types/FileField/file-field.type.d.ts

@@ -1,4 +1,5 @@
 import { OrigamFileField } from "../../components";
+import { FILE_FIELD_DISPLAY } from "../../enums";
 export type TFileSize = boolean | 1000 | 1024;
 export type TFile = Array<File> | File | null;
 /**
@@ -7,5 +8,5 @@ export type TFile = Array<File> | File | null;
  *   - `'chips'`   — each file as a closable `<OrigamChip>` inline.
  *   - `'counter'` — single "N files" line + an `<OrigamCounter>`.
  */
-export type TFileFieldDisplay = 'list' | 'chips' | 'counter';
+export type TFileFieldDisplay = `${FILE_FIELD_DISPLAY}`;
 export type TOrigamFileField = InstanceType<typeof OrigamFileField>;

package/dist/src/types/Grid/grid-item.type.d.ts

@@ -0,0 +1,9 @@
+import { OrigamGridItem } from '../../components';
+import type { TGridPlaceItems } from './grid.type';
+export type TOrigamGridItem = InstanceType<typeof OrigamGridItem>;
+/**
+ * Place-self (`align-self` + `justify-self`) on a grid item.
+ * Same matrix as place-items — aliased rather than restated so the two
+ * cannot drift.
+ */
+export type TGridPlaceSelf = TGridPlaceItems;

package/dist/src/types/Grid/grid.type.d.ts

@@ -0,0 +1,50 @@
+import { OrigamGrid } from '../../components';
+import { GRID_AUTO_FLOW } from '../../enums';
+import type { TAlign } from '../Commons/align.type';
+import type { TJustify } from '../Commons/justify.type';
+import type { TRoundedToken } from '../Commons/rounded.type';
+export type TOrigamGrid = InstanceType<typeof OrigamGrid>;
+/**
+ * Closed list of CSS `grid-auto-flow` values surfaced by `<OrigamGrid>`.
+ *
+ * The native CSS spec accepts more permutations (`column dense`,
+ * `row column dense`, …), but the matrix below is what 99 % of
+ * dashboards / page-builders need. If a consumer needs a more
+ * exotic value, they can pass a raw string via `:style` on the
+ * outer container — we don't double-validate `grid-auto-flow`.
+ */
+export type TGridAutoFlow = `${GRID_AUTO_FLOW}`;
+/**
+ * Place-items (`align-items` + `justify-items`) accepts the 4-value
+ * subset of CSS Box Alignment. `baseline` is excluded on purpose —
+ * it has no useful meaning when items can span rows / columns.
+ *
+ * Narrows the Commons `TAlign` vocabulary rather than redeclaring its
+ * literals, so a rung added to `ALIGN` cannot silently bypass this
+ * component's surface.
+ */
+export type TGridPlaceItems = Exclude<TAlign, 'baseline'>;
+/**
+ * Place-content (`align-content` + `justify-content`) — aligns the
+ * full grid inside its container when the grid is smaller than the
+ * available space. Mirrors the CSS Box Alignment matrix: the full
+ * `JUSTIFY` distribution vocabulary plus `stretch`, which only the
+ * `ALIGN` side carries.
+ */
+export type TGridPlaceContent = TJustify | Extract<TAlign, 'stretch'>;
+/**
+ * Gap size tokens (`'xs' | 'sm' | 'md' | 'lg' | 'xl'`). When the
+ * consumer passes one of these strings to the `gap` / `columnGap`
+ * / `rowGap` prop, `<OrigamGrid>` resolves it to a `var(--origam-grid---gap-{token})`
+ * reference (which itself points at `space.*` primitives via
+ * `tokens/component/grid.json`).
+ *
+ * Any other string is passed through verbatim (`'24px'`, `'1rem 2rem'`).
+ * Plain `number` is interpreted as pixels.
+ *
+ * Reuses the Commons abbreviated size vocabulary (`TRoundedToken`, see
+ * `Commons/rounded.type.ts`) rather than redeclaring the same 5 string
+ * literals — same naming convention, unrelated CSS property (gap, not
+ * radius).
+ */
+export type TGridGapSize = Exclude<TRoundedToken, 'none' | 'full'>;

package/dist/src/types/InlineEdit/inline-edit.type.d.ts

@@ -0,0 +1,13 @@
+import { OrigamInlineEdit } from '../../components';
+import type { TTextFieldType } from '../TextField/text-field.type';
+export type TOrigamInlineEdit = InstanceType<typeof OrigamInlineEdit>;
+/**
+ * Native HTML input types accepted by `<OrigamInlineEdit>` when not in
+ * multiline mode. Intentionally a closed set — `password`, `file`,
+ * `checkbox`, … don't fit the edit-in-place pattern and would require
+ * a different UX surface.
+ *
+ * Narrows the shared `TEXT_FIELD_TYPE` vocabulary rather than declaring
+ * a second, near-identical enum of HTML input types.
+ */
+export type TInlineEditInputType = Extract<TTextFieldType, 'text' | 'number' | 'email' | 'tel'>;

package/dist/src/types/ItemGroup/item-group.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamItemGroup } from '../../components';
+export type TOrigamItemGroup = InstanceType<typeof OrigamItemGroup>;

package/dist/src/types/ItemGroup/item.type.d.ts

@@ -0,0 +1,2 @@
+import { OrigamItem } from '../../components';
+export type TOrigamItem = InstanceType<typeof OrigamItem>;

package/dist/src/types/Kbd/kbd.type.d.ts

@@ -1,3 +1,4 @@
 import { OrigamKbd } from '../../components';
-export type TKbdVariant = 'filled' | 'outlined' | 'tonal';
+import { KBD_VARIANT } from '../../enums';
+export type TKbdVariant = `${KBD_VARIANT}`;
 export type TOrigamKbd = InstanceType<typeof OrigamKbd>;

package/dist/src/types/Masonry/{masonry-align.type.d.ts → masonry.type.d.ts}

@@ -1,3 +1,6 @@
+import { OrigamMasonry } from '../../components';
+import { MASONRY_ALIGN } from '../../enums';
+export type TOrigamMasonry = InstanceType<typeof OrigamMasonry>;
 /**
  * Vertical alignment of items inside a single masonry column.
  *
@@ -13,4 +16,4 @@
  * The CSS path therefore always aligns to top; switching to `'center'`
  * implicitly forces the JS fallback so the value is observable.
  */
-export type TMasonryAlign = 'top' | 'center';
+export type TMasonryAlign = `${MASONRY_ALIGN}`;