@infotrust/ui 0.0.0-stage → 0.30.1

package/dist/components/data/ItSkeleton.vue.d.ts

@@ -0,0 +1,14 @@
+type __VLS_Props = {
+    /** `table` rows, `text` lines, `list` rows (icon, title, line), or a single `block`. */
+    kind?: 'table' | 'text' | 'list' | 'block';
+    rows?: number;
+    columns?: number;
+    height?: string;
+    width?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    columns: number;
+    kind: "table" | "text" | "list" | "block";
+    rows: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/data/ItTablePaginator.vue.d.ts

@@ -0,0 +1,34 @@
+type __VLS_Props = {
+    first?: number;
+    last?: number;
+    rows?: number;
+    page?: number;
+    pageCount?: number;
+    totalRecords?: number;
+    changePageCallback?: (page: number) => void;
+    rowChangeCallback?: (rows: number) => void;
+    rowsPerPageOptions?: number[];
+    showReport?: boolean;
+    showFirstLast?: boolean;
+    reportTemplate?: string;
+    mode?: 'offset' | 'cursor';
+    hasNext?: boolean;
+    hasPrevious?: boolean;
+    busy?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    mode: "offset" | "cursor";
+    page: number;
+    rows: number;
+    first: number;
+    totalRecords: number;
+    rowsPerPageOptions: number[];
+    showFirstLast: boolean;
+    showReport: boolean;
+    reportTemplate: string;
+    hasNext: boolean;
+    hasPrevious: boolean;
+    pageCount: number;
+    last: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/data/ItTime.vue.d.ts

@@ -0,0 +1,13 @@
+import { type DateInput } from '../../format';
+type __VLS_Props = {
+    value: DateInput;
+    /** `relative` "3h ago" · `date` "Oct 9" · `datetime` "Oct 15, 6:02 AM". */
+    format?: 'relative' | 'date' | 'datetime';
+    /** The clock for `relative` (pass the page's ticking clock so it stays current). */
+    now?: Date;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    format: "relative" | "date" | "datetime";
+    now: Date;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/data/ItTreeTable.vue.d.ts

@@ -0,0 +1,109 @@
+import { type TreeTableExpandedKeys } from 'primevue/treetable';
+import type { TreeNode } from 'primevue/treenode';
+import { type ItTreeMore } from './tree-table';
+type ExpandedKeys = TreeTableExpandedKeys;
+type __VLS_Props = {
+    value?: TreeNode[] | null;
+    loading?: boolean;
+    /**
+     * The last load failed: a danger callout takes the rows' place, never an
+     * empty state. A string says why; `true` uses the default line. Retry
+     * shows when there is a `@retry` listener; `#error` replaces the
+     * callout. While `loading` (the retry), the skeleton shows as usual.
+     */
+    error?: string | boolean;
+    /** 0-based offset of the first root row on the page. Use with `v-model:first`, or omit for internal state. */
+    first?: number;
+    /** Root rows per page. */
+    rows?: number;
+    /** `auto` shows the paginator only when root rows (or totalRecords when lazy) exceed the smallest page size; in cursor mode, when hasNext or hasPrevious. */
+    paginator?: boolean | 'auto';
+    rowsPerPageOptions?: number[];
+    /** Total root rows for lazy/server pagination. */
+    totalRecords?: number;
+    /** Show the "1–10 of 48" range report next to the page links (off: the count lives in the toolbar). */
+    paginatorReport?: boolean;
+    showFirstLast?: boolean;
+    /** `cursor` for APIs that only know whether there is a next page. */
+    paginationMode?: 'offset' | 'cursor';
+    hasNext?: boolean;
+    hasPrevious?: boolean;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /** Skeleton column count while loading. */
+    skeletonColumns?: number;
+    /** Expanded node keys. Use with `v-model:expandedKeys`, or omit for internal state. */
+    expandedKeys?: ExpandedKeys;
+    /** Clicking a row that has children toggles it. */
+    rowToggle?: boolean;
+    /** Leaf rows get a pointer cursor and hover wash and emit `row-click`. */
+    leafClickable?: boolean;
+    /** Column field or columnKey that fills the remaining width. */
+    primaryColumn?: string;
+    /** Column fields or columnKeys that fit their content without wrapping. */
+    compactColumns?: readonly string[];
+    /** Keys of expanded nodes whose children are loading; each shows a skeleton child row. */
+    loadingKeys?: string[];
+    /** Row name for the chevron's aria-label ("Expand Acme GA4"). Defaults to data.name / label / title. */
+    nodeLabel?(node: TreeNode): string | undefined;
+};
+declare var __VLS_20: string, __VLS_21: any, __VLS_35: {}, __VLS_40: {
+    message: string;
+    retry: () => void;
+}, __VLS_49: {};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_20>]?: (props: typeof __VLS_21) => any;
+} & {
+    loading?: (props: typeof __VLS_35) => any;
+} & {
+    error?: (props: typeof __VLS_40) => any;
+} & {
+    empty?: (props: typeof __VLS_49) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: () => any;
+    "row-click": (event: {
+        originalEvent: Event;
+        node: TreeNode;
+    }) => any;
+    "update:expandedKeys": (keys: TreeTableExpandedKeys) => any;
+    "node-expand": (node: TreeNode) => any;
+    "node-collapse": (node: TreeNode) => any;
+    "load-more": (parentKey: string, more: ItTreeMore) => any;
+    "show-less": (parentKey: string, more: ItTreeMore) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRetry?: (() => any) | undefined;
+    "onRow-click"?: ((event: {
+        originalEvent: Event;
+        node: TreeNode;
+    }) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((keys: TreeTableExpandedKeys) => any) | undefined;
+    "onNode-expand"?: ((node: TreeNode) => any) | undefined;
+    "onNode-collapse"?: ((node: TreeNode) => any) | undefined;
+    "onLoad-more"?: ((parentKey: string, more: ItTreeMore) => any) | undefined;
+    "onShow-less"?: ((parentKey: string, more: ItTreeMore) => any) | undefined;
+}>, {
+    error: string | boolean;
+    value: TreeNode[] | null;
+    emptyTitle: string;
+    rows: number;
+    first: number;
+    rowsPerPageOptions: number[];
+    showFirstLast: boolean;
+    hasNext: boolean;
+    hasPrevious: boolean;
+    paginator: boolean | "auto";
+    paginationMode: "offset" | "cursor";
+    paginatorReport: boolean;
+    skeletonColumns: number;
+    expandedKeys: ExpandedKeys;
+    rowToggle: boolean;
+    loadingKeys: string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/data/TableChevron.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    open: boolean;
+    button?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    button: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/data/TableExpansion.vue.d.ts

@@ -0,0 +1,22 @@
+type __VLS_Props = {
+    open: boolean;
+    id: string;
+    triggerId: string;
+    label: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    closed: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClosed?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/data/column-sizing.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared width policy for plain PrimeVue Columns, matched by columnKey or field.
+ *
+ * The primary column takes `width: 100%`, so the browser shrinks every other
+ * column to its content. A column that sets a width keeps it as a minimum
+ * too: its header never moves when the rows change (collapsed groups, a
+ * filter, an empty page), and a short value never narrows it.
+ */
+export declare function columnSizing(column: Record<string, unknown> | undefined, primary?: string, compact?: readonly string[]): {
+    style?: undefined;
+} | {
+    style: {
+        width: string;
+    };
+} | {
+    style: {
+        minWidth: string;
+        width: string;
+        whiteSpace: string;
+    } | {
+        minWidth?: undefined;
+        width: string;
+        whiteSpace: string;
+    };
+} | {
+    style: {
+        minWidth: string;
+    } | {
+        minWidth?: undefined;
+    };
+};

package/dist/components/data/data-table.d.ts

@@ -0,0 +1,15 @@
+import type { DataTableEmits } from 'primevue/datatable';
+import ItDataTable from './ItDataTable.vue';
+type TableInstance = InstanceType<typeof ItDataTable>;
+/**
+ * Keep PrimeVue's complete event contract on the public wrapper. Declaring
+ * these as Vue runtime emits would remove listeners from $attrs, preventing
+ * the existing pass-through handlers from reaching the underlying table.
+ * This facade changes only declarations; it exports the same component.
+ */
+declare const _default: typeof ItDataTable & {
+    new (): Omit<TableInstance, "$emit"> & {
+        $emit: DataTableEmits & TableInstance["$emit"];
+    };
+};
+export default _default;

package/dist/components/data/highlight-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/data/highlight.d.ts

@@ -0,0 +1,3 @@
+export type ItCodeLanguage = 'json' | 'yaml' | 'javascript' | 'typescript' | 'html' | 'css' | 'sql' | 'bash' | 'text';
+/** The code as safe HTML: escaped, with .hljs-* token spans unless the language is plain text. */
+export declare function highlightCode(code: string, language: ItCodeLanguage): string;

package/dist/components/data/kpi-placement.d.ts

@@ -0,0 +1,40 @@
+/** Visible bounds for an in-page surface. The parent owns its content width. */
+export declare function kpiBounds(host: HTMLElement): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/** Space kept between an open card and the bottom of the visible area. */
+export declare const KPI_BOTTOM_GAP = 16;
+/** The detail never gets shorter than this; a card near the bottom runs past it instead. */
+export declare const KPI_MIN_DETAIL_HEIGHT = 160;
+/**
+ * Where an open card sits. It always opens out and down from its own top
+ * edge, like every other card in the row: it never moves up. Only when a
+ * scroll has taken its top out of sight does it move down, to the top of
+ * the visible area (`top`). A detail taller than the room below scrolls
+ * inside the card (see kpiDetailMaxHeight).
+ */
+export declare function kpiPlacement(card: {
+    left: number;
+    right: number;
+    top: number;
+}, bounds: {
+    left: number;
+    right: number;
+    top: number;
+}, width: number, preferred: 'left' | 'right'): {
+    align: "right" | "left";
+    width: number;
+    top: number;
+    inset: number;
+};
+/**
+ * The tallest the detail can be with the card's bottom edge still in view.
+ * `detailTop` is where the detail starts and `below` is what the card draws
+ * under it (its bottom padding and border), both in viewport pixels.
+ */
+export declare function kpiDetailMaxHeight(detailTop: number, below: number, bounds: {
+    bottom: number;
+}): number;

package/dist/components/data/kpi.d.ts

@@ -0,0 +1,16 @@
+/** Semantic emphasis for an ItKpiCard value. The card itself stays neutral. */
+export type ItKpiTone = 'default' | 'success' | 'warning' | 'danger' | 'info';
+/** Fill color of the bars in an ItKpiDetail list. */
+export type ItKpiBarTone = 'accent' | 'warning' | 'danger';
+/** One bar row in an ItKpiDetail list. */
+export interface ItKpiDetailItem {
+    /** Stable key for the row. Falls back to the row index. */
+    key?: string | number;
+    label: string;
+    /** The count. Bar width is proportional to it. */
+    value: number;
+    /** Count text to show instead of `formatCount(value)`. */
+    display?: string;
+    /** Tooltip for a selectable row, e.g. "Filter violations to GTM". */
+    title?: string;
+}

package/dist/components/data/sticky-header.d.ts

@@ -0,0 +1,9 @@
+import { type Ref } from 'vue';
+/**
+ * Let the browser own vertical stickiness when the table fits its width.
+ * PrimeVue's otherwise unused overflow container traps the sticky header.
+ * Only genuinely overflowing tables need an inset for ancestor scrolling.
+ */
+export declare function useStickyTableHeader(table: Ref<{
+    $el: HTMLElement;
+} | null>): void;

package/dist/components/data/table-skeleton.d.ts

@@ -0,0 +1,11 @@
+import { type Ref } from 'vue';
+/** Keep the visible page's geometry when its cells are replaced by skeletons. */
+export declare function useTableSkeleton(table: Ref<{
+    $el: HTMLElement;
+} | null>, loading: () => boolean, fallbackRows: () => number): {
+    hasMeasuredRows: import("vue").ComputedRef<boolean>;
+    skeletonRows: import("vue").ComputedRef<number>;
+    skeletonStyle: import("vue").ComputedRef<{
+        height: string;
+    } | undefined>;
+};

package/dist/components/data/table-source.d.ts

@@ -0,0 +1,77 @@
+/** A row's stable key (the table's `dataKey`). */
+export type ItRowKey = string | number;
+/** One request for rows. */
+export interface ItTableQuery {
+    /** 0-based index of the first row wanted. */
+    offset: number;
+    limit: number;
+    /** The table's `search`, trimmed. */
+    search: string;
+    /** The column's `sortField` (or `field`), when the person sorted. */
+    sortField: string | null;
+    /** 1 ascending, -1 descending, null unsorted. */
+    sortOrder: 1 | -1 | null;
+    /** The table's `sourceFilters`, as the app passed them. */
+    filters: Readonly<Record<string, unknown>>;
+    /** Aborted when a newer query replaces this one. */
+    signal: AbortSignal;
+}
+/** One window of rows, and how many rows match the query in all. */
+export interface ItTablePage<T = unknown> {
+    rows: readonly T[];
+    total: number;
+}
+export type ItTableSource<T = unknown> = (query: ItTableQuery) => Promise<ItTablePage<T>>;
+/**
+ * Which rows are selected. `all: false`: the rows in `keys`. `all: true`:
+ * every row that matches the table's current search and filters, except the
+ * rows in `except`. A new search, filter, or sort clears the selection, so
+ * "all" always means the query the app is showing.
+ */
+export type ItRowSelection = {
+    all: false;
+    keys: readonly ItRowKey[];
+} | {
+    all: true;
+    except: readonly ItRowKey[];
+};
+/** Nothing selected. */
+export declare const itNoSelection: () => ItRowSelection;
+/** How many rows a selection holds, given how many match the query. */
+export declare function itSelectionCount(selection: ItRowSelection | null | undefined, total: number): number;
+/** Whether the row with this key is selected. */
+export declare function itSelectionHas(selection: ItRowSelection | null | undefined, key: ItRowKey): boolean;
+/** The selection with one row turned on or off. */
+export declare function itSelectionToggle(selection: ItRowSelection, key: ItRowKey, on: boolean): ItRowSelection;
+/** Rows a 10-row page loads at once: five pages. */
+export declare const IT_TABLE_PREFETCH_PAGES = 5;
+type SortState = {
+    field: string | null;
+    order: 1 | -1 | null;
+};
+/**
+ * The window cache behind ItDataTable `source`. Windows are `rows × prefetchPages`
+ * rows long and start at multiples of that size. The page shown is cut from
+ * its window; while that window is not loaded, the table is loading (skeleton
+ * rows). Past a window's first page, the next window loads in the background.
+ * A new query (search, filters, sort) or page size drops every window.
+ */
+export declare function useTableSource(options: {
+    source: () => ItTableSource | undefined;
+    search: () => string | undefined;
+    filters: () => Readonly<Record<string, unknown>> | undefined;
+    first: () => number;
+    rows: () => number;
+    prefetchPages: () => number;
+}): {
+    pageRows: import("vue").ComputedRef<readonly unknown[] | null>;
+    total: import("vue").Ref<number | null, number | null>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<string | null>;
+    sort: import("vue").ShallowRef<SortState, SortState>;
+    queryKey: import("vue").ComputedRef<string>;
+    setSort: (field: string | null, order: number | null | undefined) => void;
+    retry: () => void;
+    refresh: () => void;
+};
+export {};

package/dist/components/data/tree-table-public.d.ts

@@ -0,0 +1,17 @@
+import type { TreeTableEmits } from 'primevue/treetable';
+import ItTreeTable from './ItTreeTable.vue';
+type TreeTableInstance = InstanceType<typeof ItTreeTable>;
+/**
+ * The public ItTreeTable: the same component, with PrimeVue's complete
+ * TreeTable event contract added to its own (`row-click`, `load-more`,
+ * `retry`), so an inline `@sort="(event) => …"` or `@node-select` handler is
+ * typed in an app. Declaring PrimeVue's events as Vue runtime emits would
+ * remove their listeners from $attrs, and they would no longer reach the
+ * underlying table (see ItDataTable's `data-table.ts`).
+ */
+declare const _default: typeof ItTreeTable & {
+    new (): Omit<TreeTableInstance, "$emit"> & {
+        $emit: TreeTableEmits & TreeTableInstance["$emit"];
+    };
+};
+export default _default;

package/dist/components/data/tree-table.d.ts

@@ -0,0 +1,30 @@
+import type { TreeNode } from 'primevue/treenode';
+/** Marker for a capped child list. Put it on a sentinel child as `data.__more`. */
+export interface ItTreeMore {
+    /** Key of the parent whose children are capped. `load-more` and `show-less` emit it. */
+    parentKey: string;
+    /** Children not shown yet. */
+    remaining?: number;
+    /**
+     * How many children one click adds. With a step (and `remaining` > 0) the row
+     * shows a "Load {step} more ({remaining} remaining)" button that emits
+     * `load-more`. Without a step the row is informational.
+     */
+    step?: number;
+    /** Informational text, e.g. "Showing first 100 of 1,240". Shown before the actions. */
+    label?: string;
+    /** Label of an extra action that emits `show-less` (e.g. "Collapse to 25"). Omit to hide it. */
+    showLessLabel?: string;
+}
+/** `data.__more` marks a "more" row; `data.__loading` marks a skeleton child row. */
+export declare const IT_TREE_MORE_FIELD = "__more";
+export declare const IT_TREE_LOADING_FIELD = "__loading";
+/** Sentinel child for a capped list. Append it as the last child of `more.parentKey`. */
+export declare function itTreeMoreNode(more: ItTreeMore): TreeNode;
+/** The `ItTreeMore` marker of a node, or undefined for a normal row. */
+export declare function itTreeMoreOf(node: TreeNode | null | undefined): ItTreeMore | undefined;
+/** Skeleton child shown under an expanded node whose key is in `loadingKeys`. */
+export declare function itTreeLoadingNode(parentKey: string): TreeNode;
+export declare function isItTreeLoadingNode(node: TreeNode | null | undefined): boolean;
+/** PrimeVue's rule: a node can expand when it has children or sets `leaf: false` (lazy children). */
+export declare function itTreeCanExpand(node: TreeNode | null | undefined): boolean;

package/dist/components/feedback/ItCallout.vue.d.ts

@@ -0,0 +1,25 @@
+type __VLS_Props = {
+    tone?: 'info' | 'success' | 'warning' | 'danger';
+    /** Bold lead-in: what happened. The default slot says what to do. */
+    title?: string;
+    closable?: boolean;
+};
+type __VLS_Slots = {
+    default?: () => unknown;
+    /** Buttons on the right (Retry, Reauthorize). */
+    actions?: () => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    tone: "info" | "success" | "warning" | "danger";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/feedback/ItConfirmHost.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/feedback/ItOverlayHost.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/feedback/ItProgressBar.vue.d.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    /** What runs: "Importing properties". Names the progress bar. */
+    label: string;
+    /** How far, from 0 to `max`. Null or undefined: indeterminate. */
+    value?: number | null;
+    /** The value at completion. */
+    max?: number;
+    /** Replaces the percentage at the right of the label line: "1,204 of 3,000 rows". Also the accessible value text. */
+    valueText?: string;
+    /** Visually hide the label line (it stays for screen readers), when text beside the bar already says what runs. */
+    hideLabel?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    max: number;
+    value: number | null;
+    hideLabel: boolean;
+    valueText: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/feedback/ItToastHost.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/forms/FieldClearButton.vue.d.ts

@@ -0,0 +1,11 @@
+type __VLS_Props = {
+    label: string;
+    disabled?: boolean;
+    inFlow?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClear?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/forms/ItAutoComplete.vue.d.ts

@@ -0,0 +1,69 @@
+declare const _default: <T, M extends T | T[] | string | null = T | null>(__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 "onUpdate:modelValue"?: ((value: M) => any) | undefined;
+        readonly onCreate?: ((query: string) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onCreate"> & {
+        /** One item (or null), or an array of items with `multiple`. */
+        modelValue?: M;
+        /**
+         * Returns the suggestions for a query. Return [] for none. `signal`
+         * aborts when a newer search starts, a pick or create ends the search,
+         * or the field unmounts; pass it to fetch to cancel the request.
+         */
+        search: (query: string, context: {
+            signal: AbortSignal;
+        }) => readonly T[] | Promise<readonly T[]>;
+        optionLabel?: string;
+        /** Field that identifies an item, used to hide picked items and match "Create". Default: the label. */
+        dataKey?: string;
+        multiple?: boolean;
+        /** Milliseconds to wait after typing before searching. */
+        debounce?: number;
+        /** Characters needed before the first search. 0 searches on focus. */
+        minLength?: number;
+        creatable?: boolean;
+        /**
+         * Single mode: the typed text is the model value (a string) when the
+         * person does not pick a suggestion; a pick still sets the item. For a
+         * field whose value may be any text, with suggestions as a shortcut (a
+         * search box, a URL pattern). Unlike `creatable`, nothing is created and
+         * no `create` event fires: the text itself is the value.
+         */
+        freeText?: boolean;
+        emptyText?: string;
+        placeholder?: string;
+        /** Accessible name and hover hint for the built-in showClear button. */
+        clearLabel?: string;
+        size?: "sm" | "md";
+        disabled?: boolean;
+        invalid?: boolean;
+        id?: string;
+        describedBy?: string;
+        pt?: Record<string, unknown>;
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        [x: string]: ((props: any) => any) | undefined;
+    } & {
+        clearicon?: (props: {
+            clearCallback: (event: Event) => void;
+        }) => any;
+    } & {
+        option?: (props: {
+            option: any;
+            index: number;
+        }) => any;
+    } & {
+        empty?: (props: {
+            query: string;
+        }) => any;
+    };
+    emit: ((evt: "update:modelValue", value: M) => void) & ((evt: "create", query: string) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/forms/ItCheckboxGroup.vue.d.ts

@@ -0,0 +1,27 @@
+import { type ItChoiceOption } from './choice';
+declare const _default: <V>(__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 "onUpdate:modelValue"?: ((value: V[]) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue"> & {
+        modelValue?: V[];
+        options: readonly ItChoiceOption<V>[];
+        /** Names the group. Omit inside ItFormField. */
+        legend?: string;
+        orientation?: "vertical" | "horizontal";
+        size?: "sm" | "md";
+        disabled?: boolean;
+        invalid?: boolean;
+        id?: string;
+        describedBy?: string;
+    } & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", value: V[]) => void;
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};