@sewadah/selaras 0.3.0 → 0.3.1

package/dist/runtime/components/Tooltip.vue

@@ -2,21 +2,26 @@
 import { TooltipArrow, TooltipContent, TooltipPortal, TooltipRoot, TooltipTrigger } from "reka-ui";
 import { computed } from "vue";
 import { tooltipTheme } from "../theme/tooltip";
+import { arrowContentProps, arrowElementProps } from "../utils/arrow";
+import { overlayPortalProps } from "../utils/overlay";
 import { resolveSlot, useComponentTheme, useThemeBindings } from "../utils/ui";
 const props = defineProps({
   text: { type: String, required: false },
   side: { type: String, required: false, default: "top" },
+  positioning: { type: Object, required: false },
+  portal: { type: [Boolean, String], required: false, skipCheck: true, default: void 0 },
   delayDuration: { type: Number, required: false, default: 200 },
   kbds: { type: Array, required: false },
-  arrow: { type: Boolean, required: false, default: true },
+  arrow: { type: [Boolean, Object], required: false, default: true },
   disabled: { type: Boolean, required: false },
   ui: { type: Object, required: false }
 });
 const theme = useComponentTheme("tooltip", tooltipTheme);
 const themeBindings = useThemeBindings();
 const ui = computed(() => theme.value());
-const contentProps = computed(() => resolveSlot(ui.value.content, props.ui?.content));
-const arrowProps = computed(() => resolveSlot(ui.value.arrow, props.ui?.arrow));
+const contentProps = computed(() => ({ ...resolveSlot(ui.value.content, props.ui?.content), ...arrowContentProps(props.arrow), ...props.positioning }));
+const portalProps = computed(() => overlayPortalProps(props.portal));
+const arrowProps = computed(() => ({ ...resolveSlot(ui.value.arrow, props.ui?.arrow), ...arrowElementProps(props.arrow) }));
 const kbdsProps = computed(() => resolveSlot(ui.value.kbds, props.ui?.kbds));
 const kbdProps = computed(() => resolveSlot(ui.value.kbd, props.ui?.kbd));
 </script>
@@ -26,7 +31,7 @@ const kbdProps = computed(() => resolveSlot(ui.value.kbd, props.ui?.kbd));
     <TooltipTrigger as-child>
       <slot />
     </TooltipTrigger>
-    <TooltipPortal>
+    <TooltipPortal v-bind="portalProps">
       <TooltipContent :side="side" :side-offset="6" :data-selaras-theme="themeBindings['data-selaras-theme']" :data-selaras-mode="themeBindings['data-selaras-mode']" :style="themeBindings.style" v-bind="contentProps">
         <slot name="content">
           {{ text }}

package/dist/runtime/components/Tooltip.vue.d.ts

@@ -1,13 +1,19 @@
 import type { TooltipThemeSlots } from '../theme/tooltip.js';
+import type { ArrowConfig } from '../utils/arrow.js';
+import type { OverlayPortal, OverlayPositioning } from '../utils/overlay.js';
 import type { UiProp } from '../utils/ui.js';
 export interface TooltipProps {
     text?: string;
     side?: 'top' | 'right' | 'bottom' | 'left';
+    /** Anchored tooltip placement. Overrides `side` when supplied. */
+    positioning?: OverlayPositioning;
+    /** Teleport target, or `false` to render inline. Defaults to `body`. */
+    portal?: OverlayPortal;
     delayDuration?: number;
     /** Keyboard shortcut hint shown alongside the text, e.g. `['⌘', 'K']` - each entry renders as its own small key badge. Takes the literal display strings, not semantic key names - there's no platform-specific symbol mapping. */
     kbds?: string[];
-    /** Set `false` to hide the little pointer triangle. */
-    arrow?: boolean;
+    /** Set `false` to hide the pointer; an object configures its size and edge clearance. */
+    arrow?: boolean | ArrowConfig;
     disabled?: boolean;
     ui?: UiProp<TooltipThemeSlots>;
 }

package/dist/runtime/composables/use-form-field.d.ts

@@ -4,6 +4,7 @@ export interface FormFieldContext {
     labelId?: string;
     name?: string;
     size?: 'sm' | 'md' | 'lg';
+    floatingLabel: ComputedRef<boolean>;
     invalid: ComputedRef<boolean>;
     describedBy: ComputedRef<string | undefined>;
 }

package/dist/runtime/composables/use-table.d.ts

@@ -34,6 +34,7 @@ export type TableRowSelectionState = RowSelectionState;
 export type TableExpandedState = ExpandedState;
 export type TableColumnVisibilityState = ColumnVisibilityState;
 export type TableGetRowId<TData extends RowData = RowData> = (row: TData, index: number) => string;
+export type TableGetSubRows<TData extends RowData = RowData> = (row: TData, index: number) => readonly TData[] | undefined;
 /** Creates TanStack v9 column definitions bound to STable's fixed feature set. */
 export declare const createTableColumnHelper: <TData extends RowData>() => import("@tanstack/vue-table").AppColumnHelper<{
     rowSortingFeature: import("@tanstack/vue-table").TableFeature;
@@ -68,6 +69,8 @@ interface UseTableProps<TData extends RowData> {
     expanded?: TableExpandedState;
     columnVisibility?: TableColumnVisibilityState;
     getRowId?: TableGetRowId<TData>;
+    tree?: boolean;
+    getSubRows?: TableGetSubRows<TData>;
     manualSorting?: boolean;
     manualFiltering?: boolean;
     manualPagination?: boolean;

package/dist/runtime/composables/use-table.js

@@ -89,12 +89,18 @@ export function useTable(props, emit, columns, columnPinning) {
   const table = useAppTable({
     data: computed(() => props.data),
     columns,
+    // TanStack enables sorting by default for accessor columns. Selaras opts
+    // columns into sorting explicitly, matching the declarative SColumn API.
+    defaultColumn: { enableSorting: false },
     enableRowSelection: computed(() => !!props.selectable),
     getRowId: props.getRowId,
-    // Row expansion otherwise only allows expanding rows that already have
-    // real hierarchical subRows - this table's own expansion is manual
-    // (detail content via the `expanded` slot), not a subRow tree.
-    getRowCanExpand: () => true,
+    getSubRows: props.tree ? props.getSubRows ?? ((row) => row.subRows) : () => void 0,
+    // Tree rows expand when they have children; detail expansion remains
+    // available on every row when tree mode is off.
+    getRowCanExpand: (row) => props.tree ? !!row.subRows?.length : true,
+    // Paginate tree roots as a unit so expanding one root does not hide later
+    // roots simply because its children consume the page-size row count.
+    paginateExpandedRows: false,
     // Opts out of the local sorted/filtered/paginated row models - state
     // still lives here (sorting/globalFilter/pageIndex above, still
     // emitting their own update:* events the normal way), only the row

package/dist/runtime/composables/use-toast.js

@@ -5,9 +5,13 @@ export function useToast() {
   const snapshotTheme = useProgrammaticThemeSnapshot();
   function add(toast) {
     if (import.meta.server)
-      throw new Error("[useToast] add() is client-only. Render server-visible status content declaratively.");
+      return -1;
     const id = service.nextId();
+    if (service.max.value <= 0)
+      return id;
     service.toasts.value.push({ ...toast, id, _theme: snapshotTheme() });
+    if (service.toasts.value.length > service.max.value)
+      service.toasts.value.splice(0, service.toasts.value.length - service.max.value);
     return id;
   }
   return { add, remove: service.remove };

package/dist/runtime/directives/hotkey.d.ts

@@ -0,0 +1,13 @@
+import type { Directive } from 'vue';
+export interface HotkeyOptions<T extends HTMLElement = HTMLElement> {
+    /** A key chord such as `mod+k`, `ctrl+shift+p`, or `escape`. */
+    keys: string;
+    /** Runs instead of clicking the bound element. */
+    handler?: (event: KeyboardEvent) => void;
+    /** Gate activation on current application state. */
+    when?: boolean | ((element: T, event: KeyboardEvent) => boolean);
+    /** Allow shortcuts while focus is in an editable control. Defaults to false. */
+    allowInEditable?: boolean;
+}
+export type HotkeyValue<T extends HTMLElement = HTMLElement> = string | HotkeyOptions<T> | false | null | undefined;
+export declare const vHotkey: Directive<HTMLElement, HotkeyValue>;

package/dist/runtime/directives/hotkey.js

@@ -0,0 +1,107 @@
+const aliases = {
+  esc: "escape",
+  return: "enter",
+  spacebar: " ",
+  space: " ",
+  up: "arrowup",
+  down: "arrowdown",
+  left: "arrowleft",
+  right: "arrowright",
+  del: "delete",
+  ctrl: "control",
+  cmd: "meta",
+  command: "meta",
+  option: "alt"
+};
+function isMacPlatform() {
+  if (typeof navigator === "undefined")
+    return false;
+  const platform = navigator.platform ?? "";
+  return /mac|iphone|ipad|ipod/i.test(platform);
+}
+function canonicalKey(key) {
+  const normalized = key.trim().toLowerCase();
+  return aliases[normalized] ?? normalized;
+}
+function parseHotkey(keys) {
+  const parts = keys.split("+").map(canonicalKey).filter(Boolean);
+  const key = parts.find((part) => !["control", "meta", "alt", "shift", "mod"].includes(part));
+  if (!key)
+    return void 0;
+  const hasMod = parts.includes("mod");
+  const mac = isMacPlatform();
+  return {
+    key,
+    ctrl: parts.includes("control") || hasMod && !mac,
+    meta: parts.includes("meta") || hasMod && mac,
+    alt: parts.includes("alt"),
+    shift: parts.includes("shift"),
+    focusScoped: key.length === 1 && !parts.some((part) => ["control", "meta", "alt", "shift", "mod"].includes(part))
+  };
+}
+function isEditable(target) {
+  if (!(target instanceof Element))
+    return false;
+  return Boolean(target.closest('input, textarea, select, [contenteditable]:not([contenteditable="false"])'));
+}
+function physicalKey(code) {
+  return /^Key([A-Z])$/.exec(code)?.[1]?.toLowerCase() ?? /^Digit(\d)$/.exec(code)?.[1];
+}
+function matches(event, hotkey) {
+  const keyMatches = canonicalKey(event.key) === hotkey.key || event.altKey && physicalKey(event.code) === hotkey.key;
+  const symbol = hotkey.key.length === 1 && hotkey.key !== " " && !/[a-z0-9]/.test(hotkey.key);
+  return keyMatches && event.ctrlKey === hotkey.ctrl && event.metaKey === hotkey.meta && event.altKey === hotkey.alt && (symbol && !hotkey.shift ? true : event.shiftKey === hotkey.shift);
+}
+function normalizeBinding(value) {
+  if (value === false || value == null)
+    return void 0;
+  return typeof value === "string" ? { keys: value } : value;
+}
+function install(element, value) {
+  const options = normalizeBinding(value);
+  const parsed = options && parseHotkey(options.keys);
+  if (!options || !parsed)
+    return void 0;
+  const listener = (event) => {
+    if (event.defaultPrevented || !matches(event, parsed))
+      return;
+    if (typeof options.when === "boolean" && !options.when)
+      return;
+    if (typeof options.when === "function" && !options.when(element, event))
+      return;
+    const activeElement = element.ownerDocument.activeElement;
+    const eventTarget = event.target;
+    if (parsed.focusScoped && !element.contains(activeElement) && !(eventTarget && (eventTarget === element || element.contains(eventTarget)))) {
+      return;
+    }
+    if (!options.allowInEditable && isEditable(event.target))
+      return;
+    event.preventDefault();
+    if (options.handler)
+      options.handler(event);
+    else
+      element.click();
+  };
+  document.addEventListener("keydown", listener);
+  return () => document.removeEventListener("keydown", listener);
+}
+export const vHotkey = {
+  mounted(element, binding) {
+    const cleanup = install(element, binding.value);
+    if (cleanup)
+      element.__selarasHotkeyCleanup = cleanup;
+  },
+  updated(element, binding) {
+    const host = element;
+    host.__selarasHotkeyCleanup?.();
+    delete host.__selarasHotkeyCleanup;
+    const cleanup = install(element, binding.value);
+    if (cleanup)
+      host.__selarasHotkeyCleanup = cleanup;
+  },
+  unmounted(element) {
+    const host = element;
+    host.__selarasHotkeyCleanup?.();
+    delete host.__selarasHotkeyCleanup;
+  }
+};

package/dist/runtime/directives/index.d.ts

@@ -1 +1,3 @@
+export * from './hotkey.js';
+export * from './mask.js';
 export * from './ripple.js';

package/dist/runtime/directives/index.js

@@ -1 +1,3 @@
+export * from "./hotkey.js";
+export * from "./mask.js";
 export * from "./ripple.js";

package/dist/runtime/directives/mask.d.ts

@@ -0,0 +1,30 @@
+import type { Directive } from 'vue';
+/** A mask placeholder character and the input characters it accepts. */
+export interface MaskToken {
+    pattern: RegExp;
+    /** Rewrites an accepted character, e.g. to uppercase it. */
+    transform?: (char: string) => string;
+}
+/** Values reported by `v-mask` after each mask update. */
+export interface MaskDetail {
+    /** The value without mask literals. This is also the value `v-model` receives. */
+    value: string;
+    /** The formatted value shown in the input. */
+    maskedValue: string;
+    /** Whether every placeholder in the mask has been filled. */
+    completed: boolean;
+}
+export interface MaskOptions {
+    mask: string;
+    /** Extra or overriding placeholder tokens, merged over the defaults (`#`, `@`, `*`). */
+    tokens?: Record<string, MaskToken>;
+    onMask?: (detail: MaskDetail) => void;
+}
+/** A mask pattern string, or options for custom tokens and the `onMask` callback. */
+export type MaskValue = string | MaskOptions | null | undefined;
+/**
+ * Formats a native input or the input inside a single-input component.
+ * `v-model` receives the raw value; the field shows the formatted one. Use
+ * `onMask` (or the bubbling `mask` event) to also read the formatted value.
+ */
+export declare const vMask: Directive<HTMLElement, MaskValue>;

package/dist/runtime/directives/mask.js

@@ -0,0 +1,165 @@
+const defaultMaskTokens = {
+  "#": { pattern: /\d/ },
+  "@": { pattern: /[a-z]/i },
+  "*": { pattern: /[\da-z]/i }
+};
+function formatMask(input, mask, tokens = defaultMaskTokens, raw = true) {
+  let masked = "";
+  let unmasked = "";
+  let inputIndex = 0;
+  let maskIndex = 0;
+  let skipped = 0;
+  const slotEnds = [];
+  while (maskIndex < mask.length && inputIndex < input.length) {
+    const maskChar = mask[maskIndex];
+    const token = tokens[maskChar];
+    const char = input[inputIndex];
+    if (token) {
+      if (token.pattern.test(char)) {
+        const accepted = token.transform ? token.transform(char) : char;
+        masked += accepted;
+        unmasked += accepted;
+        slotEnds.push(masked.length);
+        maskIndex++;
+      } else {
+        skipped++;
+      }
+      inputIndex++;
+    } else {
+      masked += maskChar;
+      if (!raw && char === maskChar && inputIndex - skipped === maskIndex)
+        inputIndex++;
+      maskIndex++;
+    }
+  }
+  let slotCount = 0;
+  for (const char of mask) {
+    if (tokens[char])
+      slotCount++;
+  }
+  return { masked, unmasked, completed: slotEnds.length === slotCount, slotEnds };
+}
+const states = /* @__PURE__ */ new WeakMap();
+let nativeDescriptor;
+function nativeValue() {
+  return nativeDescriptor ??= Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value");
+}
+function readNative(input) {
+  return nativeValue().get.call(input);
+}
+function writeNative(input, value) {
+  if (readNative(input) !== value)
+    nativeValue().set.call(input, value);
+}
+function resolveInput(element) {
+  if (element instanceof HTMLInputElement)
+    return element;
+  return element.querySelector("input") ?? void 0;
+}
+function normalize(value) {
+  if (!value)
+    return void 0;
+  return typeof value === "string" ? { mask: value } : value.mask ? value : void 0;
+}
+function resolveTokens(options) {
+  return options.tokens ? { ...defaultMaskTokens, ...options.tokens } : defaultMaskTokens;
+}
+function commit(state, result) {
+  state.masked = result.masked;
+  state.unmasked = result.unmasked;
+  writeNative(state.input, result.masked);
+  if (state.reported === result.masked)
+    return;
+  state.reported = result.masked;
+  const detail = { value: result.unmasked, maskedValue: result.masked, completed: result.completed };
+  state.onMask?.(detail);
+  state.input.dispatchEvent(new CustomEvent("mask", { bubbles: true, detail }));
+}
+function handleInput(state, event) {
+  if (event.isComposing)
+    return;
+  const { input, mask, tokens } = state;
+  const current = readNative(input);
+  const caret = input.selectionStart ?? current.length;
+  const result = formatMask(current, mask, tokens, false);
+  const inputType = event.inputType ?? "";
+  if (inputType.startsWith("delete"))
+    result.masked = result.masked.slice(0, result.slotEnds.at(-1) ?? 0);
+  const position = Math.min(formatMask(current.slice(0, caret), mask, tokens, false).masked.length, result.masked.length);
+  commit(state, result);
+  if (document.activeElement === input)
+    input.setSelectionRange(position, position);
+}
+function install(element, input, options) {
+  const state = {
+    input,
+    mask: options.mask,
+    tokens: resolveTokens(options),
+    onMask: options.onMask,
+    masked: "",
+    unmasked: "",
+    onInput: (event) => handleInput(state, event)
+  };
+  Object.defineProperty(input, "value", {
+    configurable: true,
+    enumerable: nativeValue().enumerable,
+    get: () => {
+      const current = readNative(input);
+      return current === state.masked ? state.unmasked : formatMask(current, state.mask, state.tokens, false).unmasked;
+    },
+    set: (value) => {
+      commit(state, formatMask(value == null ? "" : String(value), state.mask, state.tokens));
+    }
+  });
+  input.addEventListener("input", state.onInput, true);
+  states.set(element, state);
+  commit(state, formatMask(readNative(input), state.mask, state.tokens));
+}
+function uninstall(element, state) {
+  state.input.removeEventListener("input", state.onInput, true);
+  Reflect.deleteProperty(state.input, "value");
+  states.delete(element);
+}
+function apply(element, value) {
+  const options = normalize(value);
+  const input = resolveInput(element);
+  const state = states.get(element);
+  if (state && (!options || state.input !== input))
+    uninstall(element, state);
+  if (!options || !input)
+    return;
+  const existing = states.get(element);
+  if (!existing) {
+    install(element, input, options);
+    return;
+  }
+  existing.onMask = options.onMask;
+  const tokens = resolveTokens(options);
+  if (existing.mask === options.mask && sameTokens(existing.tokens, tokens))
+    return;
+  existing.mask = options.mask;
+  existing.tokens = tokens;
+  commit(existing, formatMask(existing.unmasked, existing.mask, existing.tokens));
+}
+function sameTokens(left, right) {
+  if (left === right)
+    return true;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => right[key] && String(left[key].pattern) === String(right[key].pattern));
+}
+export const vMask = {
+  getSSRProps() {
+    return void 0;
+  },
+  mounted(element, binding) {
+    apply(element, binding.value);
+  },
+  updated(element, binding) {
+    apply(element, binding.value);
+  },
+  beforeUnmount(element) {
+    const state = states.get(element);
+    if (state)
+      uninstall(element, state);
+  }
+};

package/dist/runtime/internal/ComboboxSelectBase.d.vue.ts

@@ -1,6 +1,8 @@
 import type { VariantProps } from 'tailwind-variants';
 import type { SelectThemeSlots } from '../theme/select.js';
+import type { RoundedArrowConfig } from '../utils/arrow.js';
 import type { ColorRole } from '../utils/color-registry.js';
+import type { OverlayPortal, OverlayPositioning } from '../utils/overlay.js';
 import type { UiProp } from '../utils/ui.js';
 import type { SelectItems, SelectOption } from './combobox-select.js';
 import { selectTheme } from '../theme/select.js';
@@ -43,7 +45,9 @@ export interface ComboboxSelectBaseProps {
     resetSearchTermOnBlur?: boolean;
     resetSearchTermOnSelect?: boolean;
     /** Shows a small pointer triangle connecting the panel to its trigger. */
-    arrow?: boolean;
+    arrow?: boolean | RoundedArrowConfig;
+    positioning?: OverlayPositioning;
+    portal?: OverlayPortal;
     /** Opts into the component's accessible small-screen presentation. */
     adaptive?: boolean;
     ui?: UiProp<SelectThemeSlots>;
@@ -55,57 +59,57 @@ export interface ComboboxSelectBaseEmits {
 }
 declare var __VLS_43: {
     item: SelectOption<import("../utils/select-contracts.js").SelectValue>;
-}, __VLS_94: {}, __VLS_101: {}, __VLS_116: {}, __VLS_140: {
+}, __VLS_98: {}, __VLS_105: {}, __VLS_120: {}, __VLS_144: {
     item: SelectOption<import("../utils/select-contracts.js").SelectValue>;
-}, __VLS_160: {
+}, __VLS_164: {
     selected: import("./combobox-select.js").ResolvedOption | undefined;
-}, __VLS_171: {}, __VLS_178: {}, __VLS_185: {}, __VLS_213: {}, __VLS_216: {}, __VLS_219: {}, __VLS_222: {}, __VLS_225: {
+}, __VLS_175: {}, __VLS_182: {}, __VLS_189: {}, __VLS_219: {}, __VLS_222: {}, __VLS_225: {}, __VLS_228: {}, __VLS_231: {
     item: SelectOption<import("../utils/select-contracts.js").SelectValue>;
-}, __VLS_228: {
+}, __VLS_234: {
     group: import("./combobox-select.js").SelectOptionGroup<import("../utils/select-contracts.js").SelectValue>;
-}, __VLS_231: {}, __VLS_267: string, __VLS_268: {}, __VLS_271: {
+}, __VLS_237: {}, __VLS_273: string, __VLS_274: {}, __VLS_277: {
     item: SelectOption<import("../utils/select-contracts.js").SelectValue>;
-}, __VLS_274: {
+}, __VLS_280: {
     group: import("./combobox-select.js").SelectOptionGroup<import("../utils/select-contracts.js").SelectValue>;
 };
 type __VLS_Slots = {} & {
-    [K in NonNullable<typeof __VLS_267>]?: (props: typeof __VLS_268) => any;
+    [K in NonNullable<typeof __VLS_273>]?: (props: typeof __VLS_274) => any;
 } & {
     item?: (props: typeof __VLS_43) => any;
 } & {
-    'clear-icon'?: (props: typeof __VLS_94) => any;
+    'clear-icon'?: (props: typeof __VLS_98) => any;
 } & {
-    'loading-icon'?: (props: typeof __VLS_101) => any;
+    'loading-icon'?: (props: typeof __VLS_105) => any;
 } & {
-    'dropdown-icon'?: (props: typeof __VLS_116) => any;
+    'dropdown-icon'?: (props: typeof __VLS_120) => any;
 } & {
-    item?: (props: typeof __VLS_140) => any;
+    item?: (props: typeof __VLS_144) => any;
 } & {
-    value?: (props: typeof __VLS_160) => any;
+    value?: (props: typeof __VLS_164) => any;
 } & {
-    'clear-icon'?: (props: typeof __VLS_171) => any;
+    'clear-icon'?: (props: typeof __VLS_175) => any;
 } & {
-    'loading-icon'?: (props: typeof __VLS_178) => any;
+    'loading-icon'?: (props: typeof __VLS_182) => any;
 } & {
-    'dropdown-icon'?: (props: typeof __VLS_185) => any;
+    'dropdown-icon'?: (props: typeof __VLS_189) => any;
 } & {
-    header?: (props: typeof __VLS_213) => any;
+    header?: (props: typeof __VLS_219) => any;
 } & {
-    'filter-icon'?: (props: typeof __VLS_216) => any;
+    'filter-icon'?: (props: typeof __VLS_222) => any;
 } & {
-    empty?: (props: typeof __VLS_219) => any;
+    empty?: (props: typeof __VLS_225) => any;
 } & {
-    'empty-filter'?: (props: typeof __VLS_222) => any;
+    'empty-filter'?: (props: typeof __VLS_228) => any;
 } & {
-    item?: (props: typeof __VLS_225) => any;
+    item?: (props: typeof __VLS_231) => any;
 } & {
-    group?: (props: typeof __VLS_228) => any;
+    group?: (props: typeof __VLS_234) => any;
 } & {
-    footer?: (props: typeof __VLS_231) => any;
+    footer?: (props: typeof __VLS_237) => any;
 } & {
-    item?: (props: typeof __VLS_271) => any;
+    item?: (props: typeof __VLS_277) => any;
 } & {
-    group?: (props: typeof __VLS_274) => any;
+    group?: (props: typeof __VLS_280) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<ComboboxSelectBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: string | number | (string | number)[] | undefined) => any;