@wow-two-beta/ui-vue 0.0.2

package/dist/presentation/display/dataGrid/CellEditor.vue.d.ts

@@ -0,0 +1,29 @@
+import { DataGridCellType, DataGridMove } from './DataGridTypes';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface CellEditorProps {
+    /** The cell's editable data type — decides which editor renders. Default `text`. */
+    type?: DataGridCellType;
+    /** The choices for a `select` cell. */
+    options?: Array<{
+        value: string | number;
+        label: string | number;
+    }>;
+    /** The draft text under edit. */
+    value: string;
+}
+declare const _default: DefineComponent<CellEditorProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    cancel: () => any;
+    "update:value": (value: string) => any;
+    commit: (move?: DataGridMove | undefined, rawValue?: string | undefined) => any;
+}, string, PublicProps, Readonly<CellEditorProps> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    "onUpdate:value"?: ((value: string) => any) | undefined;
+    onCommit?: ((move?: DataGridMove | undefined, rawValue?: string | undefined) => any) | undefined;
+}>, {
+    type: DataGridCellType;
+    options: Array<{
+        value: string | number;
+        label: string | number;
+    }>;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/display/dataGrid/DataGrid.vue.d.ts

@@ -0,0 +1,47 @@
+import { DataGridColumn } from './DataGridTypes';
+import { VNodeProps, AllowedComponentProps, ComponentCustomProps, PublicProps, ShallowUnwrapRef, ShallowRef, VNode } from 'vue';
+export interface DataGridProps<T> {
+    columns: ReadonlyArray<DataGridColumn<T>>;
+    rows: ReadonlyArray<T>;
+    /**
+     * Returns the stable key of a row.
+     *
+     * Kept a prop rather than an emit: React made it required and it is called as
+     * a plain function on every render, which is not what an emit models.
+     */
+    rowKey: (row: T) => string;
+    /** The dense row height. Default `false`. */
+    isDense?: boolean;
+}
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onRow-change"?: ((row: T, colKey: string, value: unknown) => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onRow-change"> & DataGridProps<T> & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<{
+        el: Readonly< ShallowRef<HTMLDivElement | null>>;
+    }>): void;
+    attrs: any;
+    slots: {
+        /** Overrides a column header. Falls back to the column's own `header`. */
+        header(props: {
+            column: DataGridColumn<T>;
+        }): unknown;
+        /**
+         * Overrides a body cell in read mode. Falls back to the column's `cell`
+         * renderer, then to its `accessor`.
+         */
+        cell(props: {
+            row: T;
+            column: DataGridColumn<T>;
+            rowIndex: number;
+            colIndex: number;
+        }): unknown;
+    };
+    emit: (evt: "row-change", row: T, colKey: string, value: unknown) => void;
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/presentation/display/dataGrid/DataGridTypes.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared vocabulary for the DataGrid folder.
+ *
+ * React kept these next to the component in `DataGrid.tsx`, where the private
+ * `CellEditor` could close over them. Here `CellEditor` is its own SFC, so the
+ * enums live in a sibling module both files import — the same split `table/`
+ * uses for `TableContext.ts`. `DataGridMove` stays out of the folder barrel,
+ * exactly as it was module-private in React.
+ */
+/** Defines the editable data type of a DataGrid cell. */
+export declare const DataGridCellType: {
+    /** Refers to a free-text cell. */
+    readonly Text: "text";
+    /** Refers to a numeric cell. */
+    readonly Number: "number";
+    /** Refers to a single-select cell. */
+    readonly Select: "select";
+    /** Refers to a boolean (checkbox) cell. */
+    readonly Boolean: "boolean";
+};
+export type DataGridCellType = (typeof DataGridCellType)[keyof typeof DataGridCellType];
+/** Defines the horizontal text alignment of a DataGrid column. */
+export declare const DataGridColumnAlign: {
+    /** Refers to left alignment. */
+    readonly Left: "left";
+    /** Refers to right alignment. */
+    readonly Right: "right";
+    /** Refers to centered alignment. */
+    readonly Center: "center";
+};
+export type DataGridColumnAlign = (typeof DataGridColumnAlign)[keyof typeof DataGridColumnAlign];
+/** Defines the cursor advance after a DataGrid cell edit commits. */
+export declare const DataGridMove: {
+    /** Refers to advancing to the cell on the right. */
+    readonly Right: "right";
+    /** Refers to advancing to the cell below. */
+    readonly Down: "down";
+};
+export type DataGridMove = (typeof DataGridMove)[keyof typeof DataGridMove];
+export interface DataGridColumn<T> {
+    key: string;
+    /**
+     * The header label. React took a `ReactNode`; a column is an array entry and
+     * cannot become its own slot, so the scalar stays here and the `header`
+     * scoped slot is the rich override.
+     */
+    header: string | number;
+    /** Returns the cell's underlying value. */
+    accessor: (row: T) => unknown;
+    /**
+     * Optional custom cell renderer for read mode. Returns a value rendered as
+     * text; for rich markup use the `cell` scoped slot, which receives
+     * `{ row, column, rowIndex, colIndex }`.
+     */
+    cell?: (row: T) => unknown;
+    type?: DataGridCellType;
+    /** The choices for a `select` cell. `label` is rendered as `<option>` text. */
+    options?: Array<{
+        value: string | number;
+        label: string | number;
+    }>;
+    isEditable?: boolean;
+    width?: string;
+    align?: DataGridColumnAlign;
+}

package/dist/presentation/display/dataGrid/index.d.ts

@@ -0,0 +1,2 @@
+export { default as DataGrid, type DataGridProps } from './DataGrid.vue';
+export { DataGridCellType, DataGridColumnAlign, type DataGridColumn, } from './DataGridTypes';

package/dist/presentation/display/dataTable/DataTable.vue.d.ts

@@ -0,0 +1,91 @@
+import { TableDensity } from '../table';
+import { VNodeProps, AllowedComponentProps, ComponentCustomProps, PublicProps, ShallowUnwrapRef, VNode } from 'vue';
+/** Defines the sort order of a DataTable column. */
+export declare const SortDirection: {
+    /** Refers to ascending order. */
+    readonly Asc: "asc";
+    /** Refers to descending order. */
+    readonly Desc: "desc";
+};
+export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
+/** Defines the horizontal text alignment of a DataTable column. */
+export declare const DataTableColumnAlign: {
+    /** Refers to left alignment. */
+    readonly Left: "left";
+    /** Refers to centered alignment. */
+    readonly Center: "center";
+    /** Refers to right alignment. */
+    readonly Right: "right";
+};
+export type DataTableColumnAlign = (typeof DataTableColumnAlign)[keyof typeof DataTableColumnAlign];
+export interface DataTableSort {
+    columnKey: string;
+    direction: SortDirection;
+}
+export interface DataTableColumn<T> {
+    key: string;
+    /**
+     * The header label. React took a `ReactNode`; a column is an array entry and
+     * cannot become its own slot, so the scalar stays here and the `header`
+     * scoped slot is the rich override.
+     */
+    header: string | number;
+    accessor?: (row: T) => unknown;
+    /**
+     * The per-cell renderer. Returns a value rendered as text; for rich markup
+     * use the `cell` scoped slot, which receives `{ row, column, index }`.
+     */
+    cell?: (row: T, index: number) => unknown;
+    isSortable?: boolean;
+    align?: DataTableColumnAlign;
+    width?: string;
+}
+export interface DataTableProps<T> {
+    columns: ReadonlyArray<DataTableColumn<T>>;
+    data: ReadonlyArray<T>;
+    rowKey?: (row: T, index: number) => string | number;
+    /**
+     * Fires with the clicked row and its index.
+     *
+     * Kept a prop rather than an emit because its *presence* is load-bearing — it
+     * seeds `isHoverable` and the `cursor-pointer` class, and Vue strips declared
+     * emit listeners out of `useAttrs()`.
+     */
+    onRowClick?: (row: T, index: number) => void;
+    sortBy?: DataTableSort | null;
+    defaultSortBy?: DataTableSort | null;
+    isStriped?: boolean;
+    isHoverable?: boolean;
+    density?: TableDensity;
+    isBare?: boolean;
+    /** The empty-state text. Default `No results.`; override richly via the `emptyContent` slot. */
+    emptyContent?: string | number;
+}
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onSort-change"?: ((sort: DataTableSort | null) => any) | undefined;
+    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onSort-change"> & DataTableProps<T> & Partial<{}>> & PublicProps;
+    expose(exposed: ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        /** Overrides a column header. Falls back to the column's own `header`. */
+        header(props: {
+            column: DataTableColumn<T>;
+        }): unknown;
+        /** Overrides a body cell. Falls back to the column's `cell`, then its `accessor`. */
+        cell(props: {
+            row: T;
+            column: DataTableColumn<T>;
+            index: number;
+        }): unknown;
+        /** Overrides the empty-state content. Falls back to the `emptyContent` prop. */
+        emptyContent(): unknown;
+    };
+    emit: (evt: "sort-change", sort: DataTableSort | null) => void;
+}>) => VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/presentation/display/dataTable/index.d.ts

@@ -0,0 +1 @@
+export { default as DataTable, SortDirection, DataTableColumnAlign, type DataTableProps, type DataTableColumn, type DataTableSort, } from './DataTable.vue';

package/dist/presentation/display/descriptionList/DescriptionList.vue.d.ts

@@ -0,0 +1,54 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface DescriptionListItem {
+    /** React typed this `ReactNode`; the scalar form is what an array item can carry. */
+    label: string | number;
+    value: string | number;
+}
+/** Defines the DescriptionList row layout. */
+export declare const DescriptionListLayout: {
+    /** Refers to label/value on the same line. */
+    readonly Inline: "inline";
+    /** Refers to label stacked above its value. */
+    readonly Stacked: "stacked";
+};
+export type DescriptionListLayout = (typeof DescriptionListLayout)[keyof typeof DescriptionListLayout];
+/** Defines the DescriptionList inter-row density. */
+export declare const DescriptionListDensity: {
+    /** Refers to tight row spacing. */
+    readonly Sm: "sm";
+    /** Refers to medium row spacing. */
+    readonly Md: "md";
+    /** Refers to loose row spacing. */
+    readonly Lg: "lg";
+};
+export type DescriptionListDensity = (typeof DescriptionListDensity)[keyof typeof DescriptionListDensity];
+export interface DescriptionListProps {
+    items: ReadonlyArray<DescriptionListItem>;
+    /** The layout direction. `inline` renders label/value on the same line; `stacked` puts label above. */
+    layout?: DescriptionListLayout;
+    /** The density between rows. Default `md`. */
+    density?: DescriptionListDensity;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<DescriptionListProps, {
+    el: Readonly< ShallowRef<HTMLDListElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DescriptionListProps> & Readonly<{}>, {
+    layout: DescriptionListLayout;
+    density: DescriptionListDensity;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    /** The rich override for a row's label cell. */
+    label?(props: {
+        item: DescriptionListItem;
+        index: number;
+    }): unknown;
+    /** The rich override for a row's value cell. */
+    value?(props: {
+        item: DescriptionListItem;
+        index: number;
+    }): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/display/descriptionList/index.d.ts

@@ -0,0 +1 @@
+export { default as DescriptionList, DescriptionListLayout, DescriptionListDensity, type DescriptionListProps, type DescriptionListItem, } from './DescriptionList.vue';

package/dist/presentation/display/diffViewer/DiffViewer.vue.d.ts

@@ -0,0 +1,38 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines the DiffViewer layout mode. */
+export declare const DiffView: {
+    /** Refers to side-by-side columns. */
+    readonly Split: "split";
+    /** Refers to a single interleaved column. */
+    readonly Unified: "unified";
+};
+export type DiffView = (typeof DiffView)[keyof typeof DiffView];
+export interface DiffViewerProps {
+    left: string;
+    right: string;
+    view?: DiffView;
+    /** The label for the original text. Default `"Before"`. Rich content → the `leftLabel` slot. */
+    leftLabel?: string | number;
+    /** The label for the modified text. Default `"After"`. Rich content → the `rightLabel` slot. */
+    rightLabel?: string | number;
+    hasStats?: boolean;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<DiffViewerProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DiffViewerProps> & Readonly<{}>, {
+    view: DiffView;
+    leftLabel: string | number;
+    rightLabel: string | number;
+    hasStats: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    /** The left-label override, when a plain string is not enough. */
+    leftLabel(): unknown;
+    /** The right-label override, when a plain string is not enough. */
+    rightLabel(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/display/diffViewer/index.d.ts

@@ -0,0 +1 @@
+export { default as DiffViewer, DiffView, type DiffViewerProps } from './DiffViewer.vue';

package/dist/presentation/display/emptyState/EmptyState.vue.d.ts

@@ -0,0 +1,43 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines the EmptyState visual size. */
+export declare const EmptyStateSize: {
+    /** Refers to the small layout. */
+    readonly Sm: "sm";
+    /** Refers to the medium layout. */
+    readonly Md: "md";
+    /** Refers to the large layout. */
+    readonly Lg: "lg";
+};
+export type EmptyStateSize = (typeof EmptyStateSize)[keyof typeof EmptyStateSize];
+export interface EmptyStateProps {
+    /**
+     * The heading copy. React typed this `ReactNode`; a scalar stays a prop so it
+     * remains the discriminator, and the same-named slot is the rich override.
+     */
+    title: string | number;
+    /** The body copy below the title. Same prop-plus-slot pairing as `title`. */
+    description?: string | number;
+    /** The visual size. Default `md`. */
+    size?: EmptyStateSize;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<EmptyStateProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<EmptyStateProps> & Readonly<{}>, {
+    size: EmptyStateSize;
+    description: string | number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    /** The optional icon, centered in a tinted disc. */
+    icon(): unknown;
+    /** The heading copy — overrides the `title` prop's rendering. */
+    title(): unknown;
+    /** The body copy — overrides the `description` prop's rendering. */
+    description(): unknown;
+    /** The action(s) — usually one or two `Button`s. */
+    actions(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/display/emptyState/index.d.ts

@@ -0,0 +1 @@
+export { default as EmptyState, EmptyStateSize, type EmptyStateProps } from './EmptyState.vue';

package/dist/presentation/display/eventCalendar/AgendaView.vue.d.ts

@@ -0,0 +1,13 @@
+import { Temporal } from 'temporal-polyfill';
+import { EventCalendarEvent } from './EventCalendarTypes';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface AgendaViewProps {
+    focusDay: Temporal.PlainDate;
+    events: ReadonlyArray<EventCalendarEvent>;
+}
+declare const _default: DefineComponent<AgendaViewProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "event-click": (event: EventCalendarEvent) => any;
+}, string, PublicProps, Readonly<AgendaViewProps> & Readonly<{
+    "onEvent-click"?: ((event: EventCalendarEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/display/eventCalendar/EventCalendar.vue.d.ts

@@ -0,0 +1,41 @@
+import { Temporal as TemporalValue, Temporal } from 'temporal-polyfill';
+import { EventCalendarView as EventCalendarViewValue, EventCalendarEvent, EventCalendarView } from './EventCalendarTypes';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface EventCalendarProps {
+    events: ReadonlyArray<EventCalendarEvent>;
+    /** The visible range mode, controlled. The `v-model:view` binding target. */
+    view?: EventCalendarView;
+    /** The initial view when uncontrolled. */
+    defaultView?: EventCalendarView;
+    /**
+     * The focused instant, controlled; its calendar day drives the visible month/week/day.
+     * The `v-model:date` binding target.
+     */
+    date?: Temporal.ZonedDateTime;
+    /** The initial focused instant when uncontrolled. Defaults to now. */
+    defaultDate?: Temporal.ZonedDateTime;
+    weekStart?: 0 | 1;
+    hourRange?: [number, number];
+}
+declare const _default: DefineComponent<EventCalendarProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "event-click": (event: EventCalendarEvent) => any;
+    "slot-click": (day: TemporalValue.PlainDate, hour?: number | undefined) => any;
+    "update:view": (view: EventCalendarViewValue) => any;
+    "view-change": (view: EventCalendarViewValue) => any;
+    "update:date": (date: TemporalValue.ZonedDateTime) => any;
+    "date-change": (date: TemporalValue.ZonedDateTime) => any;
+}, string, PublicProps, Readonly<EventCalendarProps> & Readonly<{
+    "onEvent-click"?: ((event: EventCalendarEvent) => any) | undefined;
+    "onSlot-click"?: ((day: TemporalValue.PlainDate, hour?: number | undefined) => any) | undefined;
+    "onUpdate:view"?: ((view: EventCalendarViewValue) => any) | undefined;
+    "onView-change"?: ((view: EventCalendarViewValue) => any) | undefined;
+    "onUpdate:date"?: ((date: TemporalValue.ZonedDateTime) => any) | undefined;
+    "onDate-change"?: ((date: TemporalValue.ZonedDateTime) => any) | undefined;
+}>, {
+    weekStart: 0 | 1;
+    hourRange: [number, number];
+    defaultView: EventCalendarView;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/display/eventCalendar/EventCalendarTypes.d.ts

@@ -0,0 +1,28 @@
+import { Temporal } from 'temporal-polyfill';
+/** Defines the EventCalendar visible range mode. */
+export declare const EventCalendarView: {
+    /** Refers to the month grid. */
+    readonly Month: "month";
+    /** Refers to the week columns. */
+    readonly Week: "week";
+    /** Refers to the single-day view. */
+    readonly Day: "day";
+    /** Refers to the chronological agenda list. */
+    readonly Agenda: "agenda";
+};
+export type EventCalendarView = (typeof EventCalendarView)[keyof typeof EventCalendarView];
+export interface EventCalendarEvent {
+    id: string;
+    /** The event title. React took a `ReactNode`; it is narrowed to a scalar for the port. */
+    title?: string | number;
+    start: Temporal.ZonedDateTime;
+    end: Temporal.ZonedDateTime;
+    color?: string;
+    isAllDay?: boolean;
+}
+/** First visible day of the week that contains `d`, honoring `weekStart`. */
+export declare function startOfWeek(d: Temporal.PlainDate, weekStart: 0 | 1): Temporal.PlainDate;
+/** Midnight instant for a calendar day in `timeZone` — the range-anchor for all-day/multi-day spans. */
+export declare function startOfCellInstant(day: Temporal.PlainDate, timeZone: string): Temporal.ZonedDateTime;
+/** The order the header's view switcher renders its radios in. */
+export declare const EVENT_CALENDAR_VIEWS: ReadonlyArray<EventCalendarView>;

package/dist/presentation/display/eventCalendar/MonthView.vue.d.ts

@@ -0,0 +1,17 @@
+import { Temporal } from 'temporal-polyfill';
+import { EventCalendarEvent } from './EventCalendarTypes';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface MonthViewProps {
+    focusDay: Temporal.PlainDate;
+    timeZone: string;
+    events: ReadonlyArray<EventCalendarEvent>;
+    weekStart: 0 | 1;
+}
+declare const _default: DefineComponent<MonthViewProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "event-click": (event: EventCalendarEvent) => any;
+    "slot-click": (day: Temporal.PlainDate, hour?: number | undefined) => any;
+}, string, PublicProps, Readonly<MonthViewProps> & Readonly<{
+    "onEvent-click"?: ((event: EventCalendarEvent) => any) | undefined;
+    "onSlot-click"?: ((day: Temporal.PlainDate, hour?: number | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/display/eventCalendar/TimeGridView.vue.d.ts

@@ -0,0 +1,18 @@
+import { Temporal } from 'temporal-polyfill';
+import { EventCalendarEvent } from './EventCalendarTypes';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface TimeGridViewProps {
+    timeZone: string;
+    events: ReadonlyArray<EventCalendarEvent>;
+    days: number;
+    firstDay: Temporal.PlainDate;
+    hourRange: [number, number];
+}
+declare const _default: DefineComponent<TimeGridViewProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "event-click": (event: EventCalendarEvent) => any;
+    "slot-click": (day: Temporal.PlainDate, hour?: number | undefined) => any;
+}, string, PublicProps, Readonly<TimeGridViewProps> & Readonly<{
+    "onEvent-click"?: ((event: EventCalendarEvent) => any) | undefined;
+    "onSlot-click"?: ((day: Temporal.PlainDate, hour?: number | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/display/eventCalendar/index.d.ts

@@ -0,0 +1,2 @@
+export { default as EventCalendar, type EventCalendarProps } from './EventCalendar.vue';
+export { EventCalendarView, type EventCalendarEvent } from './EventCalendarTypes';

package/dist/presentation/display/eyebrow/Eyebrow.vue.d.ts

@@ -0,0 +1,32 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+type EyebrowLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/** Defines the Eyebrow color tone. */
+export declare const EyebrowTone: {
+    /** Refers to the muted foreground. */
+    readonly Muted: "muted";
+    /** Refers to the subtle foreground. */
+    readonly Subtle: "subtle";
+    /** Refers to the default foreground. */
+    readonly Default: "default";
+};
+export type EyebrowTone = (typeof EyebrowTone)[keyof typeof EyebrowTone];
+export interface EyebrowProps {
+    /** The semantic heading level (1–6). Default 3. */
+    level?: EyebrowLevel;
+    /** The color tone. Default `muted`. */
+    tone?: EyebrowTone;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<EyebrowProps, {
+    el: Readonly< ShallowRef<HTMLHeadingElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<EyebrowProps> & Readonly<{}>, {
+    tone: EyebrowTone;
+    level: EyebrowLevel;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/display/eyebrow/index.d.ts

@@ -0,0 +1 @@
+export { default as Eyebrow, EyebrowTone, type EyebrowProps } from './Eyebrow.vue';

package/dist/presentation/display/featureCard/FeatureCard.vue.d.ts

@@ -0,0 +1,83 @@
+import { DefineComponent, ShallowRef, ComponentInternalInstance, VNodeProps, AllowedComponentProps, ComponentCustomProps, Attrs, Slot, ComponentPublicInstance, ComponentOptionsBase, ComponentOptionsMixin, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ComponentCustomProperties, PublicProps } from 'vue';
+import { SurfaceVariant, SurfaceTone, SurfaceRadius, SurfacePadding, SurfaceElevation } from '../../../foundation/utils';
+import { CardProps } from '..';
+import { OnCleanup } from '@vue/reactivity';
+export interface FeatureCardProps {
+    /**
+     * The feature title. React typed this `ReactNode`; a scalar stays a prop so it
+     * remains the discriminator, and the same-named slot is the rich override.
+     */
+    title: string | number;
+    /** The optional supporting copy below the title. Falls back to the default slot when omitted. */
+    description?: string | number;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<FeatureCardProps, {
+    el: Readonly< ShallowRef<({
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly variant?: SurfaceVariant | undefined;
+            readonly tone?: SurfaceTone | undefined;
+            readonly radius?: SurfaceRadius | undefined;
+            readonly padding?: SurfacePadding | undefined;
+            readonly elevation?: SurfaceElevation | undefined;
+        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        $attrs: Attrs;
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance | null;
+        $parent: ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: ComponentOptionsBase<Readonly< CardProps> & Readonly<{}>, {
+            el: Readonly< ShallowRef<HTMLDivElement | null>>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly< CardProps> & Readonly<{}>, "el"> & {
+        el: HTMLDivElement | null;
+    } & {} & ComponentCustomProperties & {} & {
+        $slots: {
+            default(): unknown;
+        };
+    }) | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<FeatureCardProps> & Readonly<{}>, {
+    description: string | number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    /** The icon node rendered inside a tinted badge (`bg-primary-soft text-primary`). Size it yourself. */
+    icon(): unknown;
+    /** The feature title — overrides the `title` prop's rendering. */
+    title(): unknown;
+    /** The supporting copy — overrides the `description` prop's rendering. */
+    description(): unknown;
+    /** The body content — used when neither `description` nor its slot is provided. */
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/display/featureCard/index.d.ts

@@ -0,0 +1 @@
+export { default as FeatureCard, type FeatureCardProps } from './FeatureCard.vue';