@synopackageland/ui 0.4.0 → 0.5.3

package/dist/components/primitives/schedule-table/schedule.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Value helpers for `ScheduleTable`.
+ *
+ * The table is a 7 day x 24 hour grid. Every cell stores one character: the index of an entry in
+ * the `options` array. The stored `modelValue` is therefore a digit string whose length depends on
+ * the time slice:
+ *
+ * | splitMinute | cells per hour | value length |
+ * | ----------- | -------------- | ------------ |
+ * | 60          | 1              | 168          |
+ * | 30          | 2              | 336          |
+ * | 15          | 4              | 672          |
+ *
+ * The string is the only supported serialization format; values are never converted to arrays or
+ * `Date` objects by the component.
+ */
+export declare const SCHEDULE_DAYS: readonly ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+export declare const SCHEDULE_SPLIT_MINUTES: readonly [60, 30, 15];
+export declare const SCHEDULE_MAX_OPTIONS = 10;
+export type ScheduleDay = (typeof SCHEDULE_DAYS)[number];
+export type ScheduleSplitMinute = (typeof SCHEDULE_SPLIT_MINUTES)[number];
+export interface ScheduleOptionEditableConfig {
+    trigger: 'hover' | 'always';
+    tooltip?: string;
+}
+export interface ScheduleOption {
+    label: string;
+    /** `blue` and `yellow` use the built-in swatches; any other string is used as a CSS color. */
+    color?: string;
+    /** Renders the option as the "empty" state with a clear glyph. */
+    clear?: boolean;
+    /** Display-only sort key (stable, defaults to 0). It never changes the stored digit. */
+    order?: number;
+    /** Shows an edit affordance and lets the table emit `edit-option`. */
+    editable?: boolean | ScheduleOptionEditableConfig;
+    /** Slot name used to render this option's control label. */
+    labelSlot?: string;
+    /** Slot name used to render every cell of this option. */
+    customCellSlot?: string;
+}
+export interface ScheduleOptionEntry {
+    option: ScheduleOption;
+    /** Position in the original `options` array; this is the digit persisted in `modelValue`. */
+    index: number;
+}
+export declare function scheduleSplitsPerHour(splitMinute: ScheduleSplitMinute): number;
+export declare function scheduleCellsPerDay(splitMinute: ScheduleSplitMinute): number;
+export declare function scheduleValueLength(splitMinute: ScheduleSplitMinute): number;
+/** True when `value` is a digit string of exactly the length required by `splitMinute`. */
+export declare function isValidScheduleValue(value: string, splitMinute: ScheduleSplitMinute): boolean;
+/** Builds a value filled with `fill` (a single digit) for the requested slice. */
+export declare function createScheduleValue(splitMinute: ScheduleSplitMinute, fill?: string): string;
+export declare function scheduleCellIndex(day: number, hour: number, hourSplitIndex: number, splitMinute: ScheduleSplitMinute): number;
+/** Stable sort by `order`; ties keep their original array position so the result is predictable. */
+export declare function orderScheduleOptions(options: ScheduleOption[]): ScheduleOptionEntry[];

package/dist/components/primitives/scrollbar/Scrollbar.vue.d.ts

@@ -0,0 +1,110 @@
+import { StyleValue } from 'vue';
+import { EnsureVisibleOptions, ScrollToPositionOptions } from './types';
+export type ScrollbarReach = {
+    top: boolean;
+    bottom: boolean;
+    left: boolean;
+    right: boolean;
+};
+export type ScrollbarViewRect = {
+    offsetHeight: number;
+    offsetWidth: number;
+    scrollHeight: number;
+    scrollWidth: number;
+};
+export type ScrollbarEnsureVisibleOptions = EnsureVisibleOptions;
+type __VLS_Props = {
+    disabled?: boolean;
+    viewTag?: string;
+    hasPadding?: boolean;
+    inverse?: boolean;
+    viewStyle?: StyleValue;
+    viewClass?: string;
+    innerStyle?: StyleValue;
+    innerClass?: string;
+    minYRailHeight?: number;
+    minYBarHeight?: number;
+    minXRailWidth?: number;
+    minXBarWidth?: number;
+    showXRail?: boolean;
+    showYRail?: boolean;
+    activeAdaptiveScrollbar?: boolean;
+    overscroll?: boolean;
+};
+declare function getScrollEl(): HTMLElement | null;
+declare function getAdaptiveContainer(): HTMLElement | null;
+declare function getScrollTop(): number;
+declare function getScrollLeft(): number;
+declare function refresh(): void;
+declare function setScroll(left?: number, top?: number): void;
+declare function scrollTo(options: ScrollToPositionOptions): void;
+declare function resetScrollTop(): void;
+declare function resetScrollLeft(): void;
+declare function updateScroll(): void;
+declare function ensureVisible(dom: HTMLElement, options?: EnsureVisibleOptions): void;
+declare var __VLS_12: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_12) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    view: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    viewRect: import('vue').ComputedRef<ScrollbarViewRect>;
+    getScrollTop: typeof getScrollTop;
+    getScrollLeft: typeof getScrollLeft;
+    getAdaptiveContainer: typeof getAdaptiveContainer;
+    setScroll: typeof setScroll;
+    getScrollEl: typeof getScrollEl;
+    resetScrollTop: typeof resetScrollTop;
+    resetScrollLeft: typeof resetScrollLeft;
+    ensureVisible: typeof ensureVisible;
+    updateScroll: typeof updateScroll;
+    scrollTo: typeof scrollTo;
+    refresh: typeof refresh;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    scroll: (event: Event, el: HTMLElement) => any;
+    reach: (reach: ScrollbarReach) => any;
+    "reach-top": () => any;
+    "reach-bottom": () => any;
+    "reach-left": () => any;
+    "reach-right": () => any;
+    "not-reach-top": () => any;
+    "not-reach-bottom": () => any;
+    "not-reach-left": () => any;
+    "not-reach-right": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onScroll?: ((event: Event, el: HTMLElement) => any) | undefined;
+    onReach?: ((reach: ScrollbarReach) => any) | undefined;
+    "onReach-top"?: (() => any) | undefined;
+    "onReach-bottom"?: (() => any) | undefined;
+    "onReach-left"?: (() => any) | undefined;
+    "onReach-right"?: (() => any) | undefined;
+    "onNot-reach-top"?: (() => any) | undefined;
+    "onNot-reach-bottom"?: (() => any) | undefined;
+    "onNot-reach-left"?: (() => any) | undefined;
+    "onNot-reach-right"?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    viewTag: string;
+    hasPadding: boolean;
+    inverse: boolean;
+    viewStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+    viewClass: string;
+    innerStyle: string | false | import('vue').CSSProperties | StyleValue[] | null;
+    innerClass: string;
+    minYRailHeight: number;
+    minYBarHeight: number;
+    minXRailWidth: number;
+    minXBarWidth: number;
+    showXRail: boolean;
+    showYRail: boolean;
+    activeAdaptiveScrollbar: boolean;
+    overscroll: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/scrollbar/types.d.ts

@@ -0,0 +1,10 @@
+export type ScrollBehaviorOption = 'auto' | 'smooth';
+export type ScrollToPositionOptions = {
+    left?: number;
+    top?: number;
+    behavior?: ScrollBehaviorOption;
+};
+export type EnsureVisibleOptions = {
+    behavior?: ScrollBehaviorOption;
+    block?: 'start' | 'end' | 'nearest';
+};

package/dist/components/primitives/segment-control/SegmentControl.vue.d.ts

@@ -0,0 +1,32 @@
+type __VLS_Props = {
+    /** Selected item value. */
+    modelValue?: string;
+    /** Accessible name of the tablist; required unless `ariaLabelledby` names it. */
+    ariaLabel?: string;
+    /** Id reference naming the tablist; takes precedence over `ariaLabel`. */
+    ariaLabelledby?: string;
+    /** Disables every item of the group. */
+    disabled?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    change: (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/segment-control/SegmentItem.vue.d.ts

@@ -0,0 +1,32 @@
+type __VLS_Props = {
+    /** Value reported to the parent `SegmentControl`. */
+    value: string;
+    disabled?: boolean;
+    /** `true` shows a decorative dot; a string is announced as the dot's label. */
+    dot?: string | boolean;
+    /** Tooltip text; `true` reuses the visible label, or `{ content }` for an object form. */
+    tooltip?: string | boolean | Record<string, unknown>;
+    /** Accessible name; required for icon-only items. */
+    ariaLabel?: string;
+};
+declare var __VLS_8: {}, __VLS_10: {}, __VLS_12: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_10) => any;
+} & {
+    suffix?: (props: typeof __VLS_12) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    disabled: boolean;
+    tooltip: string | boolean | Record<string, unknown>;
+    dot: string | boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/segment-control/context.d.ts

@@ -0,0 +1,19 @@
+import { InjectionKey, Ref } from 'vue';
+/** What a `SegmentItem` registers with its `SegmentControl`. */
+export type SegmentItemHandle = {
+    value: string;
+    disabled: () => boolean;
+    element: () => HTMLElement | undefined;
+};
+export type SegmentMove = 'previous' | 'next' | 'first' | 'last';
+export type SegmentControlContext = {
+    selected: Ref<string>;
+    groupDisabled: Ref<boolean>;
+    select: (value: string) => void;
+    register: (handle: SegmentItemHandle) => void;
+    unregister: (handle: SegmentItemHandle) => void;
+    /** Moves DOM focus only; the selection changes on Enter/Space. */
+    moveFocus: (from: string, direction: SegmentMove) => void;
+};
+export declare const SEGMENT_CONTROL_KEY: InjectionKey<SegmentControlContext>;
+export declare function injectSegmentControl(): SegmentControlContext | undefined;

package/dist/components/primitives/select/Select.vue.d.ts

@@ -1,3 +1,4 @@
+import { SelectOptions, SelectSearch } from './internal/types';
 export type SelectOption = {
     label: string;
     value: string;
@@ -5,17 +6,30 @@ export type SelectOption = {
 };
 type __VLS_Props = {
     modelValue?: string;
-    options: SelectOption[];
+    options?: SelectOptions;
     placeholder?: string;
     disabled?: boolean;
+    search?: SelectSearch;
+    minSearchChar?: number;
+    caseSensitive?: boolean;
+    searchPlaceholder?: string;
+    notFoundText?: string;
+    loadingText?: string;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:modelValue": (value: string) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
+    search: SelectSearch;
     disabled: boolean;
     placeholder: string;
+    options: SelectOptions;
+    minSearchChar: number;
+    caseSensitive: boolean;
+    searchPlaceholder: string;
+    notFoundText: string;
+    loadingText: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/primitives/select/internal/ComboboxField.vue.d.ts

@@ -0,0 +1,46 @@
+import { SelectFieldProps, SelectOption } from './types';
+declare const __VLS_export: import('vue').DefineComponent<SelectFieldProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (option: SelectOption) => any;
+    invalid: (text: string) => any;
+    "update:modelValue": (value: string | string[]) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    "update:loading": (loading: boolean) => any;
+    create: (value: string) => any;
+    "open-dropdown": () => any;
+    "close-dropdown": () => any;
+}, string, import('vue').PublicProps, Readonly<SelectFieldProps> & Readonly<{
+    onSelect?: ((option: SelectOption) => any) | undefined;
+    onInvalid?: ((text: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | string[]) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:loading"?: ((loading: boolean) => any) | undefined;
+    onCreate?: ((value: string) => any) | undefined;
+    "onOpen-dropdown"?: (() => any) | undefined;
+    "onClose-dropdown"?: (() => any) | undefined;
+}>, {
+    search: import('./types').SelectSearch;
+    loading: boolean;
+    disabled: boolean;
+    modelValue: string | string[];
+    placeholder: string;
+    ariaLabel: string;
+    ariaLabelledby: string;
+    defaultValue: string | string[];
+    options: import('./types').SelectOptions;
+    minSearchChar: number;
+    caseSensitive: boolean;
+    notFoundText: string;
+    loadingText: string;
+    multiple: boolean;
+    allowCreate: import('./types').SelectAllowCreate;
+    editable: boolean;
+    clearable: boolean;
+    createHintText: string;
+    displayLimit: number | false;
+    clearLabel: string;
+    removeTagLabel: (label: string) => string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/primitives/select/internal/SelectTag.vue.d.ts

@@ -0,0 +1,15 @@
+type __VLS_Props = {
+    label: string;
+    disabled?: boolean;
+    removeLabel?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRemove?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    removeLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/primitives/select/internal/options.d.ts

@@ -0,0 +1,17 @@
+import { SelectOption, SelectOptionGroup, SelectOptions } from './types';
+export type SelectGroup = SelectOptionGroup & {
+    key: string;
+    indent: boolean;
+};
+/**
+ * Accepts the three documented option shapes and always returns labelled groups:
+ * a plain option array becomes a single unlabelled group, an array of group
+ * entries keeps its labels, and the record form keeps the record keys.
+ */
+export declare function normalizeOptions(options: SelectOptions | undefined): SelectGroup[];
+export declare function flattenGroups(groups: SelectGroup[]): SelectOption[];
+export declare function countOptions(groups: SelectGroup[]): number;
+export declare function filterGroups(groups: SelectGroup[], query: string, caseSensitive: boolean): SelectGroup[];
+export declare function findOptionByValue(groups: SelectGroup[], value: string): SelectOption | undefined;
+/** Matches the typed text against an option value first, then against a label. */
+export declare function findOptionByText(groups: SelectGroup[], text: string, caseSensitive: boolean): SelectOption | undefined;

package/dist/components/primitives/select/internal/types.d.ts

@@ -0,0 +1,43 @@
+export type SelectOption = {
+    label: string;
+    value: string;
+    disabled?: boolean;
+};
+export type SelectOptionGroup = {
+    label?: string;
+    options: SelectOption[];
+    indent?: boolean;
+};
+/** Group options keyed by group id, as documented for the v11 options prop. */
+export type SelectOptionsRecord = Record<string, SelectOptionGroup>;
+export type SelectOptions = SelectOption[] | SelectOptionGroup[] | SelectOptionsRecord;
+export type SelectSearch = boolean | ((input: string) => Promise<SelectOptions> | SelectOptions);
+export type SelectCreateOptions = {
+    validate?: (text: string) => boolean;
+    addKey?: string[];
+};
+export type SelectAllowCreate = boolean | SelectCreateOptions;
+/** Shared prop surface of the select family's editable combobox engine. */
+export type SelectFieldProps = {
+    modelValue?: string | string[];
+    defaultValue?: string | string[];
+    multiple?: boolean;
+    options?: SelectOptions;
+    search?: SelectSearch;
+    minSearchChar?: number;
+    caseSensitive?: boolean;
+    allowCreate?: SelectAllowCreate;
+    editable?: boolean;
+    disabled?: boolean;
+    clearable?: boolean;
+    placeholder?: string;
+    loading?: boolean;
+    loadingText?: string;
+    notFoundText?: string;
+    createHintText?: string;
+    displayLimit?: number | false;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    clearLabel?: string;
+    removeTagLabel?: (label: string) => string;
+};

package/dist/components/primitives/select/internal/useSelectSearch.d.ts

@@ -0,0 +1,20 @@
+import { Ref } from 'vue';
+import { SelectGroup } from './options';
+import { SelectOptions, SelectSearch } from './types';
+export type SelectSearchSource = {
+    options: () => SelectOptions | undefined;
+    search: () => SelectSearch | undefined;
+    query: Ref<string>;
+    minSearchChar: () => number;
+    caseSensitive: () => boolean;
+};
+/**
+ * Resolves the option list the dropdown should render:
+ * `false` keeps the given options, `true` filters them locally by label and a
+ * function delegates to the caller (async results replace the given options).
+ */
+export declare function useSelectSearch(source: SelectSearchSource): {
+    baseGroups: import('vue').ComputedRef<SelectGroup[]>;
+    groups: import('vue').ComputedRef<SelectGroup[]>;
+    searching: Ref<boolean, boolean>;
+};

package/dist/components/primitives/sheet/Sheet.vue.d.ts

@@ -17,24 +17,24 @@ type __VLS_Slots = {} & {
     footer?: (props: typeof __VLS_64) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:open": (value: boolean) => any;
     escapeKeyDown: (event: KeyboardEvent) => any;
     pointerDownOutside: (event: Event) => any;
     interactOutside: (event: Event) => any;
     openAutoFocus: (event: Event) => any;
     closeAutoFocus: (event: Event) => any;
+    "update:open": (value: boolean) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:open"?: ((value: boolean) => any) | undefined;
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
     onPointerDownOutside?: ((event: Event) => any) | undefined;
     onInteractOutside?: ((event: Event) => any) | undefined;
     onOpenAutoFocus?: ((event: Event) => any) | undefined;
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     size: string;
     side: SheetSide;
-    open: boolean;
     defaultOpen: boolean;
+    open: boolean;
     closeLabel: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/primitives/skeleton/Skeleton.vue.d.ts

@@ -4,8 +4,8 @@ type __VLS_Props = {
     radius?: string;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    height: string;
     width: string;
+    height: string;
     radius: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;

package/dist/components/primitives/slider/Slider.vue.d.ts

@@ -0,0 +1,56 @@
+export type SliderInputOptions = {
+    placeholder?: string;
+    ariaLabel?: string;
+    name?: string;
+    id?: string;
+};
+type __VLS_Props = {
+    modelValue: number;
+    min: number | string;
+    max: number | string;
+    step?: number | string;
+    disabled?: boolean;
+    /** Accessible name of the handle; it also names the inline input. */
+    ariaLabel?: string;
+    /** Value bubble over the handle. Defaults to true, or false with `withInput`. */
+    tip?: boolean;
+    /** Adds an inline number input that shares `min` / `max` / `step`. */
+    withInput?: boolean | SliderInputOptions;
+    /** Custom correction applied to committed values. */
+    patchNum?: (value: number) => number;
+};
+declare var __VLS_1: {
+    value: number;
+}, __VLS_30: {}, __VLS_32: {
+    value: number;
+}, __VLS_34: {};
+type __VLS_Slots = {} & {
+    prefix?: (props: typeof __VLS_1) => any;
+} & {
+    marked?: (props: typeof __VLS_30) => any;
+} & {
+    suffix?: (props: typeof __VLS_32) => any;
+} & {
+    'input-suffix'?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (value: number) => any;
+    "update:modelValue": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onInput?: ((value: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    disabled: boolean;
+    ariaLabel: string;
+    step: number | string;
+    tip: boolean;
+    withInput: boolean | SliderInputOptions;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/space/Space.vue.d.ts

@@ -0,0 +1,27 @@
+import { SpaceAlign, SpaceDirection, SpaceJustify } from './space';
+/** Lays children out in one line with a shared gap and alignment. */
+type __VLS_Props = {
+    alignItems?: SpaceAlign;
+    /** @deprecated Use `alignItems`; kept so existing templates keep working. */
+    alignItem?: SpaceAlign;
+    justifyContent?: SpaceJustify;
+    direction?: SpaceDirection;
+    /** A spacing name (`regular`) or a pixel number. */
+    spacing?: 'none' | 'dense' | 'compact' | 'regular' | 'relaxed' | number;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    direction: SpaceDirection;
+    spacing: "none" | "dense" | "compact" | "regular" | "relaxed" | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/space/space.d.ts

@@ -0,0 +1,10 @@
+export type SpaceDirection = 'row' | 'column';
+export type SpaceSpacing = 'none' | 'dense' | 'compact' | 'regular' | 'relaxed';
+export type SpaceAlign = 'start' | 'end' | 'baseline' | 'center' | 'stretch';
+export type SpaceJustify = SpaceAlign | 'space-between' | 'space-around' | 'space-evenly';
+export type AlignItemsCss = 'flex-start' | 'flex-end' | 'baseline' | 'center' | 'stretch';
+export type JustifyContentCss = AlignItemsCss | 'space-between' | 'space-around' | 'space-evenly';
+export declare function spaceGap(spacing: SpaceSpacing | number): string;
+/** A row centres its items; a column stretches them, as SVC v11 does. */
+export declare function spaceAlignItems(direction: SpaceDirection, alignItems: SpaceAlign | undefined): AlignItemsCss;
+export declare function spaceJustifyContent(justifyContent: SpaceJustify | undefined): JustifyContentCss;

package/dist/components/primitives/superbox-select/SuperboxSelect.vue.d.ts

@@ -0,0 +1,33 @@
+import { SelectFieldProps, SelectOption } from '../select/internal/types';
+type __VLS_Props = Omit<SelectFieldProps, 'multiple' | 'modelValue' | 'defaultValue'> & {
+    modelValue?: string[];
+    defaultValue?: string[];
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (option: SelectOption) => any;
+    invalid: (text: string) => any;
+    "update:modelValue": (value: string[]) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    "update:loading": (loading: boolean) => any;
+    create: (value: string) => any;
+    "open-dropdown": () => any;
+    "close-dropdown": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((option: SelectOption) => any) | undefined;
+    onInvalid?: ((text: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:loading"?: ((loading: boolean) => any) | undefined;
+    onCreate?: ((value: string) => any) | undefined;
+    "onOpen-dropdown"?: (() => any) | undefined;
+    "onClose-dropdown"?: (() => any) | undefined;
+}>, {
+    modelValue: string[];
+    defaultValue: string[];
+    allowCreate: import('../../..').SelectAllowCreate;
+    editable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;