@ui-sdk/vue 0.0.0-stage → 0.1.0-beta.1

package/dist/tree.js

@@ -0,0 +1,209 @@
+// src/tree.ts
+import {
+  tree as treePrimitive
+} from "@ui-sdk/core/tree";
+import { defineComponent, h } from "vue";
+import { hasChild, slotContent } from "./children.js";
+import { createParts, withElement } from "./create-parts.js";
+import {
+  optionalBoolean,
+  orModel,
+  provideProps,
+  useHandle,
+  usePart,
+  usePrimitive,
+  useScope
+} from "./use-primitive.js";
+import {
+  createTreeController,
+  toggleTreeChecked,
+  treeCheckedStates,
+  treeFromPaths,
+  visibleTreeRows
+} from "@ui-sdk/core/tree";
+var parts = createParts(treePrimitive, {
+  label: "span",
+  indicator: "span",
+  checkbox: "span",
+  group: "div"
+});
+var Tree = withElement(
+  "div",
+  defineComponent({
+    name: "Tree",
+    inheritAttrs: false,
+    props: {
+      items: Array,
+      paths: Array,
+      mode: String,
+      value: { type: null, default: void 0 },
+      modelValue: {
+        type: null,
+        default: void 0
+      },
+      defaultValue: {
+        type: null,
+        default: void 0
+      },
+      activation: String,
+      expanded: { type: Array, default: void 0 },
+      defaultExpanded: {
+        type: Array,
+        default: void 0
+      },
+      expandOnPress: optionalBoolean,
+      checkable: optionalBoolean,
+      checked: { type: Array, default: void 0 },
+      defaultChecked: { type: Array, default: void 0 },
+      checkStrategy: String,
+      // A function prop beside the emit, so a returned Promise marks the item pending.
+      onAction: Function,
+      pendingAnnouncement: String,
+      loadChildren: Function,
+      current: { type: String, default: void 0 },
+      disabled: optionalBoolean,
+      focusableWhenDisabled: optionalBoolean,
+      keepMounted: optionalBoolean,
+      hiddenUntilFound: optionalBoolean,
+      announcement: Function,
+      controller: Object,
+      debug: optionalBoolean
+    },
+    emits: {
+      "update:value": (_value) => true,
+      "update:modelValue": (_value) => true,
+      valueChange: (_value, _details) => true,
+      "update:expanded": (_expanded) => true,
+      expandedChange: (_expanded, _details) => true,
+      "update:checked": (_checked) => true,
+      checkedChange: (_checked, _details) => true,
+      highlight: (_value, _details) => true
+    },
+    slots: Object,
+    setup(props, { slots, emit }) {
+      const tree = usePrimitive(treePrimitive, () => ({
+        ...props,
+        value: orModel(props.value, props.modelValue),
+        onValueChange: (value, details) => {
+          emit("valueChange", value, details);
+          if (details.canceled) {
+            return;
+          }
+          emit("update:value", value);
+          emit("update:modelValue", value);
+        },
+        onExpandedChange: (expanded, details) => {
+          emit("expandedChange", expanded, details);
+          if (!details.canceled) {
+            emit("update:expanded", expanded);
+          }
+        },
+        onCheckedChange: (checked, details) => {
+          emit("checkedChange", checked, details);
+          if (!details.canceled) {
+            emit("update:checked", checked);
+          }
+        },
+        onHighlight: (value, details) => emit("highlight", value, details)
+      }));
+      return usePart(tree, "root", void 0, void 0, {
+        tag: "div",
+        // Without content, a data tree renders its items.
+        children: (state) => {
+          const data = tree.api.internal.items();
+          return slotContent(slots.default, { state }) ?? (data && h(TreeItems, { items: data }));
+        }
+      });
+    }
+  })
+);
+var TreeItem = withElement(
+  "div",
+  defineComponent({
+    name: "TreeItem",
+    inheritAttrs: false,
+    props: {
+      value: { type: String, required: true },
+      branch: optionalBoolean,
+      disabled: optionalBoolean,
+      label: String
+    },
+    slots: Object,
+    setup(props, { slots }) {
+      const parent = useScope(treePrimitive)?.around.item;
+      provideProps(treePrimitive, "item", () => ({ value: props.value }));
+      const parentValue = () => {
+        const value = parent?.().value;
+        return typeof value === "string" ? value : null;
+      };
+      let grouped;
+      let children;
+      const item = () => ({
+        value: props.value,
+        parent: parentValue(),
+        branch: props.branch ?? grouped,
+        disabled: props.disabled,
+        label: props.label
+      });
+      const part = usePart(treePrimitive, "item", item, void 0, {
+        tag: "div",
+        children: () => children
+      });
+      return () => {
+        children = slots.default?.({ state: part.state });
+        grouped = hasChild(children, TreeGroup) || void 0;
+        return part();
+      };
+    }
+  })
+);
+var TreeItemLabel = parts.Label;
+var TreeItemIndicator = parts.Indicator;
+var TreeItemCheckbox = parts.Checkbox;
+var TreeGroup = parts.Group;
+var TreeItems = defineComponent({
+  name: "TreeItems",
+  props: {
+    items: { type: Array, required: true }
+  },
+  setup(props) {
+    const root = usePart(useHandle(treePrimitive), "root").state;
+    const render = (items) => items.map(
+      (item) => h(
+        TreeItem,
+        {
+          key: item.value,
+          value: item.value,
+          branch: item.children !== void 0,
+          disabled: item.disabled
+        },
+        () => [
+          root.checkable && h(TreeItemCheckbox),
+          h(
+            TreeItemLabel,
+            { href: item.href },
+            item.href ? {
+              render: ({ props: props2 }) => h("a", props2, item.label)
+            } : () => item.label
+          ),
+          item.children && h(TreeGroup, null, () => render(item.children))
+        ]
+      )
+    );
+    return () => render(props.items);
+  }
+});
+export {
+  Tree,
+  TreeGroup,
+  TreeItem,
+  TreeItemCheckbox,
+  TreeItemIndicator,
+  TreeItemLabel,
+  TreeItems,
+  createTreeController,
+  toggleTreeChecked,
+  treeCheckedStates,
+  treeFromPaths,
+  visibleTreeRows
+};

package/dist/trigger-menu.d.ts

@@ -0,0 +1,452 @@
+import type { Anchor, ChangeDetails, DismissAttemptDetails, Side } from "@ui-sdk/core";
+import type { AsyncOptionsStatus } from "@ui-sdk/core/async-options";
+import { type TextEditorAdapter, type TokenInsert, type TriggerDefinition, type TriggerMenuController, type TriggerMenuData, type TriggerMenuDismissReason, type TriggerMenuOpenChangeReason, type TriggerMenuQueryChangeReason, type TriggerMenuSelectDetails } from "@ui-sdk/core/trigger-menu";
+import { type PropType } from "vue";
+import { type PartSlots } from "./use-primitive.js";
+type OpenDetails = ChangeDetails<TriggerMenuOpenChangeReason> & {
+    trigger: string | null;
+};
+type QueryDetails = ChangeDetails<TriggerMenuQueryChangeReason> & {
+    trigger: string;
+    argument?: string;
+};
+type SelectHandler = (value: any, details: TriggerMenuSelectDetails<any>) => void | Promise<void | Partial<TokenInsert>>;
+/**
+ * Suggestions opened by a trigger like `@` or `/` in text. Inside a TokenInput
+ * it uses that editor; otherwise render a TriggerMenuInput, or pass `editor`.
+ * @stable
+ */
+declare const TriggerMenu: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    triggers: {
+        type: PropType<TriggerDefinition<any>[]>;
+        required: true;
+    };
+    editor: PropType<TextEditorAdapter>;
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    status: PropType<AsyncOptionsStatus>;
+    autoHighlight: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    loop: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    shortcut: StringConstructor;
+    controller: PropType<TriggerMenuController>;
+    dismissible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    debug: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    container: PropType<Element | DocumentFragment | null>;
+    onSelect: PropType<SelectHandler>;
+    pendingAnnouncement: StringConstructor;
+}>, () => (false | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[])[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (_open: boolean) => true;
+    "update:modelValue": (_open: boolean) => true;
+    openChange: (_open: boolean, _details: OpenDetails) => true;
+    openChangeComplete: (_open: boolean) => true;
+    dismissAttempt: (_details: DismissAttemptDetails<TriggerMenuDismissReason>) => true;
+    queryChange: (_query: string, _details: QueryDetails) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    triggers: {
+        type: PropType<TriggerDefinition<any>[]>;
+        required: true;
+    };
+    editor: PropType<TextEditorAdapter>;
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    status: PropType<AsyncOptionsStatus>;
+    autoHighlight: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    loop: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    shortcut: StringConstructor;
+    controller: PropType<TriggerMenuController>;
+    dismissible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    debug: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    container: PropType<Element | DocumentFragment | null>;
+    onSelect: PropType<SelectHandler>;
+    pendingAnnouncement: StringConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_open: boolean) => any) | undefined;
+    "onUpdate:open"?: ((_open: boolean) => any) | undefined;
+    onOpenChange?: ((_open: boolean, _details: OpenDetails) => any) | undefined;
+    onOpenChangeComplete?: ((_open: boolean) => any) | undefined;
+    onDismissAttempt?: ((_details: DismissAttemptDetails<TriggerMenuDismissReason>) => any) | undefined;
+    onQueryChange?: ((_query: string, _details: QueryDetails) => any) | undefined;
+}>, {
+    open: boolean;
+    debug: boolean;
+    loop: boolean;
+    dismissible: boolean;
+    autoHighlight: boolean;
+    modelValue: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * The text field the menu suggests into: a `<textarea>`, or an `<input>` from the `render` slot.
+ * @stable
+ */
+declare const TriggerMenuInput: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/trigger-menu").TriggerMenuInputState>>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/trigger-menu").TriggerMenuInputState>>>, "textarea">;
+/**
+ * The popup that holds the suggestions, anchored at the caret.
+ * @stable
+ */
+declare const TriggerMenuContent: import("./create-parts.js").ElementPart<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    side: PropType<Side>;
+    align: PropType<"start" | "center" | "end">;
+    sideOffset: NumberConstructor;
+    alignOffset: NumberConstructor;
+    collisionPadding: NumberConstructor;
+    arrowPadding: NumberConstructor;
+    anchor: PropType<Anchor | string | null>;
+    keepMounted: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    container: PropType<Element | DocumentFragment | null>;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    side: PropType<Side>;
+    align: PropType<"start" | "center" | "end">;
+    sideOffset: NumberConstructor;
+    alignOffset: NumberConstructor;
+    collisionPadding: NumberConstructor;
+    arrowPadding: NumberConstructor;
+    anchor: PropType<Anchor | string | null>;
+    keepMounted: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    container: PropType<Element | DocumentFragment | null>;
+}>> & Readonly<{}>, {
+    keepMounted: boolean;
+}, PartSlots<import("@ui-sdk/core/trigger-menu").TriggerMenuPrimitive, "content">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * The listbox. Without children, it renders the current trigger's items, filtered.
+ * @stable
+ */
+declare const TriggerMenuList: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<import("@ui-sdk/core/trigger-menu").TriggerMenuContentState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/trigger-menu").TriggerMenuPrimitive, "list">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * A suggestion. Choosing it inserts it into the text.
+ * @stable
+ */
+declare const TriggerMenuItem: new <A extends unknown = string>(props: import("@ui-sdk/core/trigger-menu").TriggerMenuItemProps<A> & {
+    onSelect?: ((value: A, details: TriggerMenuSelectDetails<A>) => any) | undefined;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    [x: `data${Capitalize<string>}`]: unknown;
+    contextmenu?: string | undefined | undefined;
+    style?: import("vue").StyleValue;
+    title?: string | undefined | undefined;
+    dir?: string | undefined | undefined;
+    'aria-labelledby'?: string | undefined | undefined;
+    'aria-label'?: string | undefined | undefined;
+    'aria-disabled'?: (boolean | "true" | "false") | undefined;
+    radiogroup?: string | undefined | undefined;
+    'aria-activedescendant'?: string | undefined | undefined;
+    'aria-autocomplete'?: "none" | "inline" | "list" | "both" | undefined | undefined;
+    'aria-checked'?: "mixed" | (boolean | "true" | "false") | undefined;
+    'aria-colcount'?: (string | number) | undefined;
+    'aria-colindex'?: (string | number) | undefined;
+    'aria-colspan'?: (string | number) | undefined;
+    'aria-expanded'?: (boolean | "true" | "false") | undefined;
+    'aria-level'?: (string | number) | undefined;
+    'aria-modal'?: (boolean | "true" | "false") | undefined;
+    'aria-multiline'?: (boolean | "true" | "false") | undefined;
+    'aria-multiselectable'?: (boolean | "true" | "false") | undefined;
+    'aria-orientation'?: "horizontal" | "vertical" | undefined | undefined;
+    'aria-placeholder'?: string | undefined | undefined;
+    'aria-posinset'?: (string | number) | undefined;
+    'aria-pressed'?: "mixed" | (boolean | "true" | "false") | undefined;
+    'aria-readonly'?: (boolean | "true" | "false") | undefined;
+    'aria-required'?: (boolean | "true" | "false") | undefined;
+    'aria-rowcount'?: (string | number) | undefined;
+    'aria-rowindex'?: (string | number) | undefined;
+    'aria-rowspan'?: (string | number) | undefined;
+    'aria-selected'?: (boolean | "true" | "false") | undefined;
+    'aria-setsize'?: (string | number) | undefined;
+    'aria-sort'?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+    'aria-valuemax'?: (string | number) | undefined;
+    'aria-valuemin'?: (string | number) | undefined;
+    'aria-valuenow'?: (string | number) | undefined;
+    'aria-valuetext'?: string | undefined | undefined;
+    id?: string | undefined | undefined;
+    role?: string | undefined | undefined;
+    tabindex?: (string | number) | undefined;
+    property?: string | undefined | undefined;
+    autocapitalize?: string | undefined | undefined;
+    autocorrect?: string | undefined | undefined;
+    spellcheck?: (boolean | "true" | "false") | undefined;
+    inputmode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+    enterkeyhint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+    'aria-controls'?: string | undefined | undefined;
+    'aria-describedby'?: string | undefined | undefined;
+    'aria-details'?: string | undefined | undefined;
+    'aria-errormessage'?: string | undefined | undefined;
+    'aria-flowto'?: string | undefined | undefined;
+    'aria-owns'?: string | undefined | undefined;
+    part?: string | undefined;
+    hidden?: "" | "hidden" | "until-found" | (boolean | "true" | "false") | undefined;
+    'aria-live'?: "off" | "assertive" | "polite" | undefined | undefined;
+    'aria-atomic'?: (boolean | "true" | "false") | undefined;
+    color?: string | undefined | undefined;
+    'aria-hidden'?: (boolean | "true" | "false") | undefined;
+    onChange?: ((payload: Event) => void) | undefined;
+    lang?: string | undefined | undefined;
+    innerHTML?: string | undefined | undefined;
+    onScroll?: ((payload: Event) => void) | undefined;
+    contenteditable?: "inherit" | (boolean | "true" | "false") | "plaintext-only" | undefined;
+    inert?: (boolean | "true" | "false") | undefined;
+    translate?: "yes" | "no" | undefined | undefined;
+    results?: (string | number) | undefined;
+    'aria-busy'?: (boolean | "true" | "false") | undefined;
+    onSubmit?: ((payload: SubmitEvent) => void) | undefined;
+    onBlur?: ((payload: FocusEvent) => void) | undefined;
+    'aria-keyshortcuts'?: string | undefined | undefined;
+    'aria-haspopup'?: "dialog" | "menu" | "grid" | "listbox" | "tree" | (boolean | "true" | "false") | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    prefix?: string | undefined | undefined;
+    enterKeyHint?: "search" | "done" | "enter" | "go" | "next" | "previous" | "send" | undefined;
+    'aria-current'?: "time" | "date" | "location" | "step" | "page" | (boolean | "true" | "false") | undefined;
+    class?: import("vue").ClassValue;
+    placeholder?: string | undefined | undefined;
+    'aria-invalid'?: (boolean | "true" | "false") | "grammar" | "spelling" | undefined;
+    onError?: ((payload: Event) => void) | undefined;
+    onInput?: ((payload: InputEvent) => void) | undefined;
+    onReset?: ((payload: Event) => void) | undefined;
+    onFullscreenchange?: ((payload: Event) => void) | undefined;
+    onFullscreenerror?: ((payload: Event) => void) | undefined;
+    onAbort?: ((payload: UIEvent) => void) | undefined;
+    onAnimationcancel?: ((payload: AnimationEvent) => void) | undefined;
+    onAnimationend?: ((payload: AnimationEvent) => void) | undefined;
+    onAnimationiteration?: ((payload: AnimationEvent) => void) | undefined;
+    onAnimationstart?: ((payload: AnimationEvent) => void) | undefined;
+    onAuxclick?: ((payload: PointerEvent) => void) | undefined;
+    onBeforeinput?: ((payload: InputEvent) => void) | undefined;
+    onBeforetoggle?: ((payload: ToggleEvent) => void) | undefined;
+    onCanplay?: ((payload: Event) => void) | undefined;
+    onCanplaythrough?: ((payload: Event) => void) | undefined;
+    onClick?: ((payload: PointerEvent) => void) | undefined;
+    onCompositionend?: ((payload: CompositionEvent) => void) | undefined;
+    onCompositionstart?: ((payload: CompositionEvent) => void) | undefined;
+    onCompositionupdate?: ((payload: CompositionEvent) => void) | undefined;
+    onContextmenu?: ((payload: PointerEvent) => void) | undefined;
+    onCopy?: ((payload: ClipboardEvent) => void) | undefined;
+    onCut?: ((payload: ClipboardEvent) => void) | undefined;
+    onDblclick?: ((payload: MouseEvent) => void) | undefined;
+    onDrag?: ((payload: DragEvent) => void) | undefined;
+    onDragend?: ((payload: DragEvent) => void) | undefined;
+    onDragenter?: ((payload: DragEvent) => void) | undefined;
+    onDragleave?: ((payload: DragEvent) => void) | undefined;
+    onDragover?: ((payload: DragEvent) => void) | undefined;
+    onDragstart?: ((payload: DragEvent) => void) | undefined;
+    onDrop?: ((payload: DragEvent) => void) | undefined;
+    onDurationchange?: ((payload: Event) => void) | undefined;
+    onEmptied?: ((payload: Event) => void) | undefined;
+    onEnded?: ((payload: Event) => void) | undefined;
+    onFocus?: ((payload: FocusEvent) => void) | undefined;
+    onFocusin?: ((payload: FocusEvent) => void) | undefined;
+    onFocusout?: ((payload: FocusEvent) => void) | undefined;
+    onFormdata?: ((payload: FormDataEvent) => void) | undefined;
+    onGotpointercapture?: ((payload: PointerEvent) => void) | undefined;
+    onInvalid?: ((payload: Event) => void) | undefined;
+    onKeydown?: ((payload: KeyboardEvent) => void) | undefined;
+    onKeypress?: ((payload: KeyboardEvent) => void) | undefined;
+    onKeyup?: ((payload: KeyboardEvent) => void) | undefined;
+    onLoad?: ((payload: Event) => void) | undefined;
+    onLoadeddata?: ((payload: Event) => void) | undefined;
+    onLoadedmetadata?: ((payload: Event) => void) | undefined;
+    onLoadstart?: ((payload: Event) => void) | undefined;
+    onLostpointercapture?: ((payload: PointerEvent) => void) | undefined;
+    onMousedown?: ((payload: MouseEvent) => void) | undefined;
+    onMouseenter?: ((payload: MouseEvent) => void) | undefined;
+    onMouseleave?: ((payload: MouseEvent) => void) | undefined;
+    onMousemove?: ((payload: MouseEvent) => void) | undefined;
+    onMouseout?: ((payload: MouseEvent) => void) | undefined;
+    onMouseover?: ((payload: MouseEvent) => void) | undefined;
+    onMouseup?: ((payload: MouseEvent) => void) | undefined;
+    onPaste?: ((payload: ClipboardEvent) => void) | undefined;
+    onPause?: ((payload: Event) => void) | undefined;
+    onPlay?: ((payload: Event) => void) | undefined;
+    onPlaying?: ((payload: Event) => void) | undefined;
+    onPointercancel?: ((payload: PointerEvent) => void) | undefined;
+    onPointerdown?: ((payload: PointerEvent) => void) | undefined;
+    onPointerenter?: ((payload: PointerEvent) => void) | undefined;
+    onPointerleave?: ((payload: PointerEvent) => void) | undefined;
+    onPointermove?: ((payload: PointerEvent) => void) | undefined;
+    onPointerout?: ((payload: PointerEvent) => void) | undefined;
+    onPointerover?: ((payload: PointerEvent) => void) | undefined;
+    onPointerup?: ((payload: PointerEvent) => void) | undefined;
+    onProgress?: ((payload: ProgressEvent<EventTarget>) => void) | undefined;
+    onRatechange?: ((payload: Event) => void) | undefined;
+    onScrollend?: ((payload: Event) => void) | undefined;
+    onSecuritypolicyviolation?: ((payload: SecurityPolicyViolationEvent) => void) | undefined;
+    onSeeked?: ((payload: Event) => void) | undefined;
+    onSeeking?: ((payload: Event) => void) | undefined;
+    onStalled?: ((payload: Event) => void) | undefined;
+    onSuspend?: ((payload: Event) => void) | undefined;
+    onTimeupdate?: ((payload: Event) => void) | undefined;
+    onToggle?: ((payload: ToggleEvent) => void) | undefined;
+    onTouchcancel?: ((payload: TouchEvent) => void) | undefined;
+    onTouchend?: ((payload: TouchEvent) => void) | undefined;
+    onTouchmove?: ((payload: TouchEvent) => void) | undefined;
+    onTouchstart?: ((payload: TouchEvent) => void) | undefined;
+    onTransitioncancel?: ((payload: TransitionEvent) => void) | undefined;
+    onTransitionend?: ((payload: TransitionEvent) => void) | undefined;
+    onTransitionrun?: ((payload: TransitionEvent) => void) | undefined;
+    onTransitionstart?: ((payload: TransitionEvent) => void) | undefined;
+    onVolumechange?: ((payload: Event) => void) | undefined;
+    onWaiting?: ((payload: Event) => void) | undefined;
+    onWheel?: ((payload: WheelEvent) => void) | undefined;
+    onDragexit?: ((payload: DragEvent) => void) | undefined;
+    onEncrypted?: ((payload: MediaEncryptedEvent) => void) | undefined;
+    accesskey?: string | undefined | undefined;
+    about?: string | undefined | undefined;
+    datatype?: string | undefined | undefined;
+    inlist?: any;
+    resource?: string | undefined | undefined;
+    typeof?: string | undefined | undefined;
+    vocab?: string | undefined | undefined;
+    autosave?: string | undefined | undefined;
+    itemprop?: string | undefined | undefined;
+    itemscope?: (boolean | "true" | "false") | undefined;
+    itemtype?: string | undefined | undefined;
+    itemid?: string | undefined | undefined;
+    itemref?: string | undefined | undefined;
+    security?: string | undefined | undefined;
+    unselectable?: "on" | "off" | undefined | undefined;
+    is?: string | undefined | undefined;
+    exportparts?: string | undefined;
+    'aria-dropeffect'?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+    'aria-grabbed'?: (boolean | "true" | "false") | undefined;
+    'aria-relevant'?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+    'aria-roledescription'?: string | undefined | undefined;
+}) => import("./create-parts.js").ElementInstance<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/trigger-menu").TriggerMenuItemProps<A>, "onSelect">, {
+    select: (value: A, details: TriggerMenuSelectDetails<A>) => true;
+} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/trigger-menu").TriggerMenuItemState>>>, "div">;
+/**
+ * An icon inside a suggestion. Screen readers, typeahead and filtering
+ * skip it, and `mirror` flips it in right-to-left text.
+ * @stable
+ */
+declare const TriggerMenuItemIcon: Pick<import("vue").DefineSetupFnComponent<Omit<NoInfer<import("@ui-sdk/core/renderer").ItemIconProps & {
+    item?: string;
+}> & import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<{
+    mirror: boolean;
+}>>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<NoInfer<import("@ui-sdk/core/renderer").ItemIconProps & {
+    item?: string;
+}> & import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<{
+    mirror: boolean;
+}>>>, "span">;
+/**
+ * A group of items, named by its `TriggerMenuGroupLabel`.
+ * @stable
+ */
+declare const TriggerMenuGroup: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<{}>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<{}>>, "div">;
+/**
+ * The group's heading, which names the group.
+ * @stable
+ */
+declare const TriggerMenuGroupLabel: Pick<import("vue").DefineSetupFnComponent<Omit<NoInfer<{
+    group?: string;
+}> & import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<{}>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<NoInfer<{
+    group?: string;
+}> & import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<{}>>, "div">;
+/**
+ * A line between items or groups, hidden from screen readers.
+ * @stable
+ */
+declare const TriggerMenuSeparator: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<{}>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<{}>>, "div">;
+/**
+ * Shown while no item matches. Rendering it keeps the menu open with no matches.
+ * @stable
+ */
+declare const TriggerMenuEmpty: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<import("@ui-sdk/core/trigger-menu").TriggerMenuEmptyState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/trigger-menu").TriggerMenuPrimitive, "empty">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * A polite status, outside the popup. Without a default slot, it says the count and the keys once typing pauses.
+ * @stable
+ */
+declare const TriggerMenuStatus: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<import("@ui-sdk/core/trigger-menu").TriggerMenuStatusState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/trigger-menu").TriggerMenuPrimitive, "status">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * Ghost text at the caret for the arguments still to type. Without a default slot, the hints.
+ * @stable
+ */
+declare const TriggerMenuHint: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<import("@ui-sdk/core/trigger-menu").TriggerMenuHintState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/trigger-menu").TriggerMenuPrimitive, "hint">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "span">;
+/**
+ * Renders data items. Used by data menus, and available for custom layouts.
+ * @stable
+ */
+declare const TriggerMenuItems: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    items: {
+        type: PropType<TriggerMenuData<any>>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    items: {
+        type: PropType<TriggerMenuData<any>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export { createTriggerMenuController, textFieldAdapter, } from "@ui-sdk/core/trigger-menu";
+export type { EditorChange, EditorReplaceOptions, ListFilter, ListItem, ListSeparator, TextEditorAdapter, TextRange, TextRect, Token, TokenInsert, TriggerAfter, TriggerArgument, TriggerBoundary, TriggerDefinition, TriggerItemsLoader, TriggerMatch, TriggerMenuApi, TriggerMenuChangeOptions, TriggerMenuContentProps, TriggerMenuContentState, TriggerMenuController, TriggerMenuData, TriggerMenuDataGroup, TriggerMenuDataItem, TriggerMenuDismissReason, TriggerMenuEmptyState, TriggerMenuHintState, TriggerMenuInputState, TriggerMenuItemIconProps, TriggerMenuItemIconState, TriggerMenuItemProps, TriggerMenuItemState, TriggerMenuOpenChangeReason, TriggerMenuOptions, TriggerMenuPrimitive, TriggerMenuQueryChangeReason, TriggerMenuSelectDetails, TriggerMenuStatusState, TriggerRule, } from "@ui-sdk/core/trigger-menu";
+export { TriggerMenu, TriggerMenuContent, TriggerMenuEmpty, TriggerMenuGroup, TriggerMenuGroupLabel, TriggerMenuHint, TriggerMenuInput, TriggerMenuItem, TriggerMenuItemIcon, TriggerMenuItems, TriggerMenuList, TriggerMenuSeparator, TriggerMenuStatus, };