@cjlapao/ui-kit-vue 0.2.0

package/dist/types/vue/src/components/StatusSpinner.vue.d.ts

@@ -0,0 +1,17 @@
+import type { TrueColor } from "../theme/Theme";
+export type StatusSpinnerIntent = TrueColor;
+export type StatusSpinnerSize = "xs" | "sm" | "md" | "lg";
+export interface StatusSpinnerProps {
+    intent?: StatusSpinnerIntent;
+    size?: StatusSpinnerSize;
+    animated?: boolean;
+    label?: string;
+}
+declare const _default: import("vue").DefineComponent<StatusSpinnerProps, {
+    el: import("vue").Ref<HTMLSpanElement | null, HTMLSpanElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StatusSpinnerProps> & Readonly<{}>, {
+    size: StatusSpinnerSize;
+    intent: StatusSpinnerIntent;
+    animated: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/Stepper.vue.d.ts

@@ -0,0 +1,84 @@
+import type { VNode, VNodeChild } from "vue";
+import type { PanelTone } from "./Panel.vue";
+import type { LoaderProps } from "./Loader.vue";
+import type { IconName } from "../icons/registry";
+export type StepStatus = "pending" | "active" | "completed" | "error";
+export interface StepperStep {
+    id?: string;
+    title: string | VNode;
+    subtitle?: string | VNode;
+    description?: string | VNode;
+    content?: string | VNode;
+    icon?: IconName | VNode;
+    optionalLabel?: string | VNode;
+    status?: StepStatus;
+    disabled?: boolean;
+}
+export type Step = StepperStep;
+export type StepperOrientation = "horizontal" | "vertical";
+export type StepperVariant = "card" | "minimal";
+export type StepperSize = "sm" | "md" | "lg";
+export type StepperConnector = "line" | "progress" | "none";
+export type StepperProgressBarPosition = "top" | "bottom";
+export type StepperConnectorAlign = "left" | "center" | "right";
+export interface StepperProps {
+    steps: StepperStep[];
+    currentIndex?: number;
+    currentStepId?: string;
+    defaultCurrentIndex?: number;
+    defaultCurrentStepId?: string;
+    completedStepIds?: string[];
+    orientation?: StepperOrientation;
+    variant?: StepperVariant;
+    size?: StepperSize;
+    tone?: PanelTone;
+    connector?: StepperConnector;
+    interactive?: boolean;
+    readOnly?: boolean;
+    animated?: boolean;
+    transitionMs?: number;
+    showProgressSummary?: boolean;
+    showProgressBar?: boolean;
+    progressBarPosition?: "top" | "bottom";
+    progressPrecision?: number;
+    progressLabel?: string | VNode;
+    renderActions?: (step: StepperStep, index: number) => VNodeChild;
+    loaderStepIds?: string[];
+    loading?: boolean;
+    loaderTitle?: string | VNode;
+    loaderMessage?: string | VNode;
+    loaderType?: LoaderProps["variant"];
+    loaderProgress?: number;
+    loaderColor?: LoaderProps["color"];
+    wrapperClassName?: string;
+    headerClassName?: string;
+    stepClassName?: string;
+    contentClassName?: string;
+    stepMaxHeight?: number | string;
+    connectNodes?: boolean;
+    connectorAlign?: StepperConnectorAlign;
+    /** Override whether the underline bar is shown beneath each step's title/subtitle. When omitted the variant default is used (`card` → true, `minimal` → false). */
+    showStepUnderline?: boolean;
+}
+declare const _default: import("vue").DefineComponent<StepperProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (index: number, stepId?: string | undefined) => any;
+    stepClick: (step: StepperStep, index: number) => any;
+}, string, import("vue").PublicProps, Readonly<StepperProps> & Readonly<{
+    onChange?: ((index: number, stepId?: string | undefined) => any) | undefined;
+    onStepClick?: ((step: StepperStep, index: number) => any) | undefined;
+}>, {
+    tone: PanelTone;
+    variant: StepperVariant;
+    size: StepperSize;
+    loading: boolean;
+    loaderType: "spinner" | "progress";
+    orientation: StepperOrientation;
+    connector: StepperConnector;
+    interactive: boolean;
+    showProgressSummary: boolean;
+    showProgressBar: boolean;
+    progressPrecision: number;
+    connectNodes: boolean;
+    connectorAlign: StepperConnectorAlign;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/Table.vue.d.ts

@@ -0,0 +1,245 @@
+import type { VNodeChild } from "vue";
+import type { TrueColor } from "../theme";
+import type { PanelTone } from "./Panel.vue";
+type SortDirection = "asc" | "desc";
+export interface TableSortState {
+    columnId: string;
+    direction: SortDirection;
+}
+export interface TablePaginationState {
+    page: number;
+    pageSize: number;
+    total: number;
+    onPageChange: (page: number) => void;
+    onPageSizeChange: (pageSize: number) => void;
+}
+/** Unified snapshot of all user-configurable table preferences. */
+export interface TableSettings {
+    columnVisibility?: Record<string, boolean>;
+    columnWidths?: Record<string, number>;
+    activeView?: "table" | "panel";
+    groupBy?: string | null;
+    showGroupHeader?: boolean;
+    stickyColumns?: Record<string, "left" | "right">;
+}
+type AccessorFn<T> = (row: T, index: number) => VNodeChild;
+export interface TableColumn<T> {
+    id: string;
+    header: VNodeChild;
+    accessor?: keyof T | AccessorFn<T>;
+    render?: (row: T, index: number) => VNodeChild;
+    /** Override the value used for sorting when render returns a non-primitive (e.g. an icon). */
+    sortValue?: (row: T) => string | number;
+    width?: string | number;
+    minWidth?: string | number;
+    maxWidth?: string | number;
+    align?: "left" | "center" | "right";
+    sortable?: boolean;
+    tooltip?: string;
+    className?: string;
+    headerClassName?: string;
+    sticky?: "left" | "right";
+    /** When true, this column is excluded from user preference menus (hide/show, group-by, sticky). */
+    isActionsColumn?: boolean;
+    /** When true, the column starts hidden by default but can still be enabled from the Columns menu. */
+    defaultHidden?: boolean;
+    /** When false, this column cannot be hidden via the column visibility toggle. Defaults to true. */
+    hideable?: boolean;
+    /** When false, this column will not appear in the group-by picker. Defaults to true. */
+    groupable?: boolean;
+    /** When false, this column cannot be resized even when `resizableColumns` is set on the table. Defaults to true. */
+    resizable?: boolean;
+    /**
+     * Returns a plain string used as the group key and header label when this column is the active
+     * group-by. Use this when `render` returns VNodes (which would otherwise give "[object Object]").
+     * Falls back to: accessor result → sortValue → render result (only if a primitive string/number).
+     */
+    groupValue?: (row: T) => string;
+    /**
+     * Background Tailwind class(es) applied to sticky cells so they remain opaque over scrolled
+     * content. Defaults to `'bg-white dark:bg-neutral-900'`. Pass `'bg-transparent'` to let the
+     * row/table background show through instead.
+     */
+    stickyBackground?: string;
+    /**
+     * Per-row variant of `stickyBackground`. When provided, takes precedence over `stickyBackground`
+     * for the matching row. Return `undefined` to fall back to the static `stickyBackground`.
+     */
+    stickyBackgroundFn?: (row: T, index: number) => string | undefined;
+}
+export type Column<T> = TableColumn<T>;
+export type TableVariant = "default" | "compact" | "minimal" | "bordered" | "flat";
+export interface TableProps<T> {
+    columns?: TableColumn<T>[];
+    data: T[];
+    selectedItems?: T[];
+    rowKey?: (row: T, index: number) => string | number;
+    variant?: TableVariant;
+    tone?: PanelTone;
+    /** Theme color applied to action buttons, sort indicators, group dot, badges, and pagination. */
+    color?: TrueColor;
+    striped?: boolean;
+    noBorders?: boolean;
+    hoverable?: boolean;
+    stickyHeader?: boolean;
+    /**
+     * When true, the last column is pinned to the right edge and stays visible
+     * while the other columns scroll horizontally. A left border separator is
+     * added automatically to distinguish it from the scrolling content.
+     */
+    stickyActions?: boolean;
+    loading?: boolean;
+    loadingMessage?: string;
+    loaderType?: "spinner" | "progress";
+    loaderProgress?: number;
+    emptyState?: VNodeChild;
+    sortState?: TableSortState;
+    defaultSort?: TableSortState;
+    headerActions?: VNodeChild;
+    footer?: VNodeChild;
+    pagination?: TablePaginationState;
+    maxHeight?: string | number;
+    rowClassName?: (row: T, index: number) => string;
+    /** When provided and returns true for a row, that row is rendered with an intense accent background and a pulsing left-border indicator to signal new/updated content. */
+    rowHighlight?: (row: T, index: number) => boolean;
+    tableClassName?: string;
+    bodyClassName?: string;
+    fullHeight?: boolean;
+    manualSorting?: boolean;
+    /** When true, wraps the table in a rounded border regardless of the variant. */
+    rounded?: boolean;
+    /** Title shown in the header bar alongside headerActions / view toggle. Defaults to empty. */
+    headerTitle?: string;
+    /**
+     * Initial column visibility map (`columnId → visible`).
+     * Serialise with `JSON.stringify` to save; parse and pass back to restore.
+     */
+    columnVisibility?: Record<string, boolean>;
+    /**
+     * When true, shows the column visibility toggle button in the header bar.
+     * Defaults to false — the icon is hidden unless this prop is explicitly set.
+     */
+    showColumnSelector?: boolean;
+    /**
+     * Enables drag-to-resize column headers. Each column can opt out via `column.resizable = false`.
+     */
+    resizableColumns?: boolean;
+    /**
+     * Initial column width map (`columnId → pixels`).
+     * Serialise with `JSON.stringify` to save; parse and pass back to restore.
+     */
+    columnWidths?: Record<string, number>;
+    /** Renders each row as a panel card. When provided alongside columns, a view toggle appears in the header. */
+    panelItem?: (row: T, index: number) => VNodeChild;
+    /** Initial view when both columns and panelItem are provided. Defaults to "table". */
+    defaultView?: "table" | "panel";
+    /** CSS class(es) for the panel grid container. Defaults to a 1–3 column responsive grid. */
+    panelGridClassName?: string;
+    /**
+     * Minimum width of each panel card. The grid uses CSS `auto-fill` to place
+     * as many columns as fit the container — adapts to the parent width with no
+     * hard breakpoints. Accepts a CSS length string ("280px", "20rem") or a
+     * number treated as px. When set, takes precedence over the column layout in
+     * `panelGridClassName` (extra classes from `panelGridClassName` still apply).
+     */
+    panelMinItemWidth?: string | number;
+    /**
+     * Gap between panel cards when `panelMinItemWidth` is set. Accepts a CSS
+     * length string ("1rem", "16px") or a number treated as px. Defaults to
+     * "1rem" (= `gap-4`). The value is applied via inline style so it cannot be
+     * accidentally overridden by a conflicting Tailwind class.
+     */
+    panelGap?: string | number;
+    /**
+     * Maximum width of each panel card when `panelMinItemWidth` is set. Prevents cards from
+     * growing too wide on large containers. Accepts a CSS length string ("480px", "30rem") or
+     * a number treated as px. When omitted, cards stretch to fill available space (`1fr`).
+     */
+    panelMaxItemWidth?: string | number;
+    /**
+     * When provided, the panel view only renders the first row for each unique key value.
+     * Use this when `data` is a flattened list but panels should show one card per logical entity.
+     * Example: `:panel-deduplicate-by="(row) => row.manifest.id"`
+     */
+    panelDeduplicateBy?: (row: T) => string | number;
+    /**
+     * Column id to group rows by (code-defined).
+     * Always applied; the user cannot override this via the UI.
+     */
+    groupBy?: string;
+    /**
+     * When true, a grouping control is shown in the header letting the user
+     * configure grouping at runtime. Only effective when `groupBy` is not set.
+     */
+    groupable?: boolean;
+    /**
+     * Initial user-configured group column id (uncontrolled).
+     * Pass the persisted value here on mount to restore previous state.
+     * Only used when `groupable` is true and `groupBy` is not set.
+     */
+    defaultGroupBy?: string;
+    /** Whether to show a header row for each group value. Defaults to true. */
+    showGroupHeader?: boolean;
+    /** Whether groups start expanded. Defaults to true. */
+    defaultGroupExpanded?: boolean;
+    /**
+     * When true, a sticky-column picker is shown in the header bar letting the
+     * user pin individual columns to the left or right at runtime.
+     */
+    userStickyColumns?: boolean;
+    /**
+     * Initial user-configured sticky map (`columnId → 'left' | 'right'`).
+     * Pass the persisted value here on mount to restore previous state.
+     */
+    defaultStickyColumns?: Record<string, "left" | "right">;
+    /**
+     * Unified table settings snapshot. Fields here take precedence over the
+     * individual initial-value props (`columnVisibility`, `columnWidths`,
+     * `defaultView`, `defaultGroupBy`, `defaultStickyColumns`).
+     * Pass a previously persisted value to restore all settings on mount.
+     */
+    tableSettings?: TableSettings;
+}
+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 onSortChange?: ((sort: TableSortState | null) => any) | undefined;
+        readonly onViewChange?: ((view: "panel" | "table") => any) | undefined;
+        readonly onColumnVisibilityChange?: ((visibility: Record<string, boolean>) => any) | undefined;
+        readonly onColumnWidthChange?: ((widths: Record<string, number>) => any) | undefined;
+        readonly onGroupByChange?: ((columnId: string | null) => any) | undefined;
+        readonly onStickyColumnsChange?: ((config: Record<string, "left" | "right">) => any) | undefined;
+        readonly onTableSettingsChange?: ((settings: TableSettings) => any) | undefined;
+        readonly onRowClick?: ((row: T, index: number) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onSortChange" | "onViewChange" | "onColumnVisibilityChange" | "onColumnWidthChange" | "onGroupByChange" | "onStickyColumnsChange" | "onTableSettingsChange" | "onRowClick"> & TableProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        /** Overrides the `headerActions` prop. */
+        headerActions?: () => VNodeChild;
+        /** Overrides the `footer` prop. */
+        footer?: () => VNodeChild;
+        /** Overrides the `emptyState` prop. */
+        emptyState?: () => VNodeChild;
+        /** Scoped-slot alternative to the `panelItem` render prop. */
+        panelItem?: (slotProps: {
+            row: T;
+            index: number;
+        }) => VNodeChild;
+    };
+    emit: {
+        (e: "sortChange", sort: TableSortState | null): void;
+        (e: "rowClick", row: T, index: number): void;
+        (e: "viewChange", view: "table" | "panel"): void;
+        (e: "columnVisibilityChange", visibility: Record<string, boolean>): void;
+        (e: "columnWidthChange", widths: Record<string, number>): void;
+        (e: "groupByChange", columnId: string | null): void;
+        (e: "stickyColumnsChange", config: Record<string, "left" | "right">): void;
+        (e: "tableSettingsChange", settings: TableSettings): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/vue/src/components/Tabs.vue.d.ts

@@ -0,0 +1,74 @@
+import type { VNode } from "vue";
+import { type TrueColor } from "../theme/Theme";
+export type TabsVariant = "underline" | "soft" | "pill" | "segmented" | "minimal";
+export type TabsSize = "sm" | "md" | "lg";
+export type TabsOrientation = "horizontal" | "vertical";
+export type TabsJustify = "start" | "center" | "end" | "between";
+export interface TabItemAction {
+    id?: string;
+    label?: string | VNode;
+    /** Render a fully custom node in the tab bar. When set, `icon` and `onClick` are ignored. */
+    node?: VNode;
+    icon?: string | VNode;
+    onClick?: () => void;
+    color?: TrueColor;
+    active?: boolean;
+}
+export interface TabItem {
+    id: string;
+    label: string | VNode;
+    icon?: string | VNode;
+    description?: string | VNode;
+    badge?: string | number;
+    disabled?: boolean;
+    panel?: string | VNode;
+    badgeColor?: TrueColor;
+    actions?: TabItemAction[];
+}
+export interface TabsProps {
+    items: TabItem[];
+    modelValue?: string;
+    defaultValue?: string;
+    variant?: TabsVariant;
+    size?: TabsSize;
+    color?: TrueColor;
+    orientation?: TabsOrientation;
+    justify?: TabsJustify;
+    fullWidth?: boolean;
+    listClassName?: string;
+    allowReselect?: boolean;
+    panelIdPrefix?: string;
+    showDividers?: boolean;
+    hideUnderlineContainer?: boolean;
+    /** Override the variant's container class (e.g. to customise the underline border color). Takes precedence over hideUnderlineContainer. */
+    containerClassName?: string;
+    panelClassName?: string;
+    /**
+     * When true, renders a gradient fade at the top of each panel's scroll area so
+     * content doesn't hard-clip against the tab bar when scrolled. Default: true.
+     * Pass a Tailwind `from-*` colour to match your panel background (default: white / neutral-900 dark).
+     */
+    scrollFade?: boolean;
+    scrollFadeFrom?: string;
+}
+declare const _default: import("vue").DefineComponent<TabsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    change: (id: string, item: TabItem) => any;
+    "update:modelValue": (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<TabsProps> & Readonly<{
+    onChange?: ((id: string, item: TabItem) => any) | undefined;
+    "onUpdate:modelValue"?: ((id: string) => any) | undefined;
+}>, {
+    color: TrueColor;
+    variant: TabsVariant;
+    size: TabsSize;
+    fullWidth: boolean;
+    justify: TabsJustify;
+    orientation: TabsOrientation;
+    allowReselect: boolean;
+    panelIdPrefix: string;
+    showDividers: boolean;
+    hideUnderlineContainer: boolean;
+    scrollFade: boolean;
+    scrollFadeFrom: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/TagPanel.vue.d.ts

@@ -0,0 +1,61 @@
+import type { VNodeChild } from "vue";
+import type { SectionSize, SectionVariant } from "./Section.vue";
+import type { PillVariant, PillSize } from "./Pill.vue";
+import type { TrueColor } from "../theme/Theme";
+export interface TagPanelTag {
+    id?: string;
+    label: string;
+    /** Pill tone. Defaults to `'neutral'`. */
+    tone?: TrueColor;
+    /** Pill variant. Defaults to `'soft'`. */
+    variant?: PillVariant;
+    /** Pill size. Defaults to `'sm'`. */
+    size?: PillSize;
+    /** Optional leading icon inside the pill. */
+    icon?: VNodeChild;
+    children?: VNodeChild;
+}
+export interface TagPanelProps {
+    /** Section heading. Omit entirely to hide the header. */
+    title?: string;
+    /** Optional secondary line below the title. */
+    subtitle?: string;
+    /** Tags to render as pills. */
+    tags: TagPanelTag[];
+    /**
+     * Maximum number of pills shown before a `+N` overflow pill appears.
+     * Set to `0` to always show all. Default: `5`.
+     */
+    tagLimit?: number;
+    /**
+     * Tone used for the `+N` overflow pill.
+     * Defaults to `'neutral'`.
+     */
+    overflowTone?: TrueColor;
+    /** Controls header padding and font size. Defaults to `'md'`. */
+    size?: SectionSize;
+    /** Visual style of the section header. Defaults to `'uppercase'`. */
+    variant?: SectionVariant;
+    /** Extra classes for the tags container. */
+    bodyClassName?: string;
+    /** Remove all padding from the section header. */
+    noPadding?: boolean;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<TagPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TagPanelProps> & Readonly<{}>, {
+    tagLimit: number;
+    overflowTone: TrueColor;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    title?: (props: {}) => any;
+} & {
+    subtitle?: (props: {}) => any;
+} & {
+    actions?: (props: {}) => any;
+} & {
+    emptyState?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/TagPicker.vue.d.ts

@@ -0,0 +1,93 @@
+import type { VNode } from "vue";
+import { type TrueColor } from "../theme/Theme";
+import type { PickerTag } from "./Picker.vue";
+/** A known option in the dropdown list */
+export interface TagPickerItem {
+    id: string;
+    label: string;
+    /** Optional leading icon */
+    icon?: string | VNode;
+    /** Optional Pills rendered at the trailing edge of each row */
+    tags?: PickerTag[];
+}
+export interface TagPickerProps {
+    /** Known options shown in the dropdown */
+    items: TagPickerItem[];
+    /**
+     * Controlled array of selected values (`v-model`).
+     * For known items this is the item's `id`.
+     * For free-text entries created via `allowCreate`, this is the raw text itself.
+     */
+    modelValue: string[];
+    /**
+     * Show a "Create '…'" row when the search query doesn't match any existing item.
+     * Default: false
+     */
+    allowCreate?: boolean;
+    /**
+     * Called when the user confirms a new free-text value.
+     * If omitted, the raw text is added to value[] directly via update:modelValue.
+     */
+    onCreateItem?: (label: string) => void;
+    /**
+     * When false, behaves as single-select: picking a new item replaces the current value.
+     * Default: true (multi-select with tag pills)
+     */
+    multi?: boolean;
+    /** Placeholder shown in the trigger when nothing is selected */
+    placeholder?: string;
+    /** Placeholder inside the search input */
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    loading?: boolean;
+    loadingMessage?: string;
+    color?: TrueColor;
+    itemColor?: TrueColor;
+    /**
+     * When true, the dropdown positions against the viewport instead of a clipping ancestor.
+     * Useful when the component is inside a modal or constrained panel.
+     * Default: false
+     */
+    escapeBoundary?: boolean;
+    /**
+     * Maximum number of tag pills shown before a "+N" overflow pill appears.
+     * Set to 0 or undefined to show all tags. Default: 3
+     */
+    tagLimit?: number;
+    /**
+     * When true, items added during this session (not present in the initial value)
+     * are highlighted with an emerald color cue — both in the trigger pills and in
+     * the dropdown list. Default: true
+     */
+    highlightNew?: boolean;
+    disabled?: boolean;
+    /** When true, hides the remove (×) button on tag pills and prevents adding/removing items via the dropdown. @default false */
+    readOnly?: boolean;
+    /**
+     * Optional function to normalize a value before it is added.
+     * Applied to both free-text creations and known-item selections.
+     * The return value is what gets stored in `value[]`.
+     * Example: `(v) => v.toUpperCase()`
+     */
+    normalizeValue?: (value: string) => string;
+}
+declare const _default: import("vue").DefineComponent<TagPickerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:modelValue": (values: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<TagPickerProps> & Readonly<{
+    "onUpdate:modelValue"?: ((values: string[]) => any) | undefined;
+}>, {
+    color: TrueColor;
+    disabled: boolean;
+    placeholder: string;
+    loading: boolean;
+    emptyMessage: string;
+    searchPlaceholder: string;
+    loadingMessage: string;
+    escapeBoundary: boolean;
+    multi: boolean;
+    allowCreate: boolean;
+    tagLimit: number;
+    highlightNew: boolean;
+    readOnly: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/Textarea.vue.d.ts

@@ -0,0 +1,26 @@
+import type { TrueColor } from "../theme/Theme";
+type TextareaSize = "sm" | "md" | "lg";
+type TextareaValidationStatus = "none" | "error" | "success";
+type TextareaResize = "none" | "vertical" | "horizontal" | "both";
+export interface TextareaProps {
+    /** Current value of the textarea (v-model). */
+    modelValue?: string;
+    size?: TextareaSize;
+    tone?: TrueColor;
+    validationStatus?: TextareaValidationStatus;
+    resize?: TextareaResize;
+    helpText?: string;
+}
+declare const _default: import("vue").DefineComponent<TextareaProps, {
+    el: import("vue").Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<TextareaProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    tone: TrueColor;
+    size: TextareaSize;
+    resize: TextareaResize;
+    validationStatus: TextareaValidationStatus;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/vue/src/components/TimelinePanel/TimelinePanel.vue.d.ts

@@ -0,0 +1,23 @@
+import type { PanelPadding } from "../Panel.vue";
+import type { TimelinePanelProps } from "./types";
+import type { PanelVariant, PanelCorner } from "../Panel.vue";
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<TimelinePanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TimelinePanelProps> & Readonly<{}>, {
+    tone: import("../../index.js").TrueColor;
+    variant: PanelVariant;
+    loading: boolean;
+    padding: PanelPadding;
+    corner: PanelCorner;
+    showTrunkDots: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    title?: (props: {}) => any;
+} & {
+    headerAction?: (props: {}) => any;
+} & {
+    emptyState?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/vue/src/components/TimelinePanel/index.d.ts

@@ -0,0 +1,2 @@
+export { default as TimelinePanel } from "./TimelinePanel.vue";
+export type { TimelinePanelProps, TimelinePanelItem, TimelinePanelAction, TimelinePanelOverflowItem, TimelinePanelHeaderAction, TimelinePanelVariant, TimelinePanelPadding, TimelinePanelCorner, } from "./types";