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

package/dist/segmented-input.d.ts

@@ -0,0 +1,76 @@
+import type { ChangeDetails } from "@ui-sdk/core";
+import type { dateInput, DateInputController, DateInputSegmentData, DateInputValueChangeReason, DateMatchers, HourCycle } from "@ui-sdk/core/date-input";
+import { type ExtractPropTypes, type PropType, type SetupContext } from "vue";
+import { type PartSlots } from "./use-primitive.js";
+type Segmented = typeof dateInput;
+declare const rootProps: {
+    value: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    modelValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    defaultValue: {
+        type: PropType<string | null>;
+        default: undefined;
+    };
+    granularity: PropType<"day" | "hour" | "minute" | "second">;
+    hourCycle: PropType<HourCycle>;
+    min: StringConstructor;
+    max: StringConstructor;
+    locale: StringConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    required: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    name: StringConstructor;
+    form: StringConstructor;
+    controller: PropType<DateInputController>;
+    debug: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+};
+declare const rootEmits: {
+    "update:value": (_value: string | null) => boolean;
+    "update:modelValue": (_value: string | null) => boolean;
+    valueChange: (_value: string | null, _details: ChangeDetails<DateInputValueChangeReason>) => boolean;
+};
+type RootProps = ExtractPropTypes<typeof rootProps> & {
+    unavailable?: DateMatchers;
+};
+declare function setupRoot(primitive: Segmented, Segment: ReturnType<typeof defineSegment>, props: RootProps, { attrs, slots, emit, }: SetupContext<typeof rootEmits, PartSlots<Segmented, "root">>): (() => 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/date-input").DateInputState>;
+};
+declare function defineSegment(primitive: Segmented, name: string): import("./create-parts.js").ElementPart<import("vue").DefineComponent<ExtractPropTypes<{
+    segment: {
+        type: PropType<DateInputSegmentData>;
+        required: true;
+    };
+}>, (() => 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/date-input").DateInputSegmentState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    segment: {
+        type: PropType<DateInputSegmentData>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/date-input").DateInputPrimitive, "segment">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "input">;
+export { defineSegment, rootEmits, rootProps, type Segmented, setupRoot };

package/dist/segmented-input.js

@@ -0,0 +1,115 @@
+// src/segmented-input.ts
+import {
+  defineComponent,
+  h
+} from "vue";
+import { slotContent } from "./children.js";
+import { useFieldControl } from "./field-context.js";
+import { withElement } from "./create-parts.js";
+import { readOnlyOf } from "./text-control.js";
+import {
+  optionalBoolean,
+  orModel,
+  useHandle,
+  usePart,
+  usePrimitive
+} from "./use-primitive.js";
+var rootProps = {
+  value: { type: String, default: void 0 },
+  modelValue: { type: String, default: void 0 },
+  defaultValue: { type: String, default: void 0 },
+  granularity: String,
+  hourCycle: Number,
+  min: String,
+  max: String,
+  locale: String,
+  disabled: optionalBoolean,
+  readOnly: optionalBoolean,
+  required: optionalBoolean,
+  name: String,
+  form: String,
+  controller: Object,
+  debug: optionalBoolean
+};
+var rootEmits = {
+  "update:value": (_value) => true,
+  "update:modelValue": (_value) => true,
+  valueChange: (_value, _details) => true
+};
+function setupRoot(primitive, Segment, props, {
+  attrs,
+  slots,
+  emit
+}) {
+  const field = useFieldControl();
+  const handle = usePrimitive(primitive, () => ({
+    value: orModel(props.value, props.modelValue),
+    defaultValue: props.defaultValue,
+    granularity: props.granularity,
+    hourCycle: props.hourCycle,
+    min: props.min,
+    max: props.max,
+    unavailable: props.unavailable,
+    locale: props.locale,
+    disabled: props.disabled || field?.disabled(),
+    readOnly: readOnlyOf(props, attrs),
+    required: props.required,
+    name: props.name ?? field?.name(),
+    form: props.form,
+    controller: props.controller,
+    debug: props.debug,
+    onValueChange: (value, details) => {
+      emit("valueChange", value, details);
+      if (details.canceled) {
+        return;
+      }
+      emit("update:value", value);
+      emit("update:modelValue", value);
+    }
+  }));
+  const hidden = () => h("input", handle.slot("hidden-input"));
+  return usePart(handle, "root", void 0, void 0, {
+    tag: "div",
+    children: (state) => [
+      slotContent(slots.default, { state }) ?? state.segments.map(
+        (segment) => h(Segment, { key: segment.key, segment })
+      ),
+      hidden()
+    ],
+    extend: (root) => field ? field.props(root) : root
+  });
+}
+function defineSegment(primitive, name) {
+  return withElement(
+    "input",
+    defineComponent({
+      name,
+      inheritAttrs: false,
+      props: {
+        segment: {
+          type: Object,
+          required: true
+        }
+      },
+      slots: Object,
+      setup(props, { slots }) {
+        const part = () => ({ segment: props.segment, id: props.segment.key });
+        if (props.segment.editable) {
+          return usePart(useHandle(primitive), "segment", part, void 0, {
+            tag: "input"
+          });
+        }
+        return usePart(useHandle(primitive), "segment", part, void 0, {
+          tag: "span",
+          children: (state) => slotContent(slots.default, { state }) ?? state.text
+        });
+      }
+    })
+  );
+}
+export {
+  defineSegment,
+  rootEmits,
+  rootProps,
+  setupRoot
+};

package/dist/select.d.ts

@@ -0,0 +1,458 @@
+import type { Anchor, Side } from "@ui-sdk/core";
+import type { AsyncOptionsStatus } from "@ui-sdk/core/async-options";
+import { type ListData, type SelectController, type SelectOptions } from "@ui-sdk/core/select";
+import { type PropType, type VNode } from "vue";
+import { type RenderableWith, type RootInstanceOf, type RootPropsOf } from "./create-parts.js";
+import { type PartSlots } from "./use-primitive.js";
+/**
+ * Picks one value, or several with `multiple`, from a list in a popup.
+ * @stable
+ */
+declare const Select: SelectComponent;
+type SelectProps<T, Multiple extends boolean | undefined> = SelectOptions<T, Multiple> & {
+    multiple?: Multiple;
+};
+type SelectComponent = {
+    new <T = string>(props: RootPropsOf<SelectProps<T, false>>): RootInstanceOf<SelectProps<T, false>>;
+    new <T = string>(props: RootPropsOf<SelectProps<T, true>>): RootInstanceOf<SelectProps<T, true>>;
+    new <T = string, Multiple extends boolean | undefined = boolean>(props: RootPropsOf<SelectProps<T, Multiple> & {
+        multiple: Multiple;
+    }>): RootInstanceOf<SelectProps<T, Multiple>>;
+} & RenderableWith<SelectProps<any, boolean | undefined>>;
+/**
+ * A visible label for the select. Pressing it focuses the trigger, like a native select's label.
+ * @stable
+ */
+declare const SelectLabel: 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 button that opens the list: a combobox named by the label. Typing on it selects the item that matches.
+ * @stable
+ */
+declare const SelectTrigger: import("./create-parts.js").ElementPart<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    controller: PropType<SelectController<any, any>>;
+}>, () => unknown, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    disabled: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    controller: PropType<SelectController<any, any>>;
+}>> & Readonly<{}>, {
+    disabled: boolean;
+}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "trigger">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "button">;
+/**
+ * The selected item's label, or the placeholder. Renders it for you when it has no children.
+ * @stable
+ */
+declare const SelectValue: import("./create-parts.js").ElementPart<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    placeholder: StringConstructor;
+    maxLabels: NumberConstructor;
+    getMoreLabel: PropType<(count: number) => string>;
+}>, () => unknown, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    placeholder: StringConstructor;
+    maxLabels: NumberConstructor;
+    getMoreLabel: PropType<(count: number) => string>;
+}>> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "value">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "span">;
+/**
+ * The popup that holds the items, positioned against the trigger.
+ * @stable
+ */
+declare const SelectContent: 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>;
+    alignItemWithTrigger: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    keepMounted: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    container: PropType<Element | DocumentFragment | null>;
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | 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>;
+    alignItemWithTrigger: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    keepMounted: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    container: PropType<Element | DocumentFragment | null>;
+}>> & Readonly<{}>, {
+    keepMounted: boolean;
+    alignItemWithTrigger: boolean;
+}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "content">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * The listbox, when the content holds more than items, like a `SelectInput`. Without children, it renders the select's `items` that match.
+ * @stable
+ */
+declare const SelectList: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<import("@ui-sdk/core/select").SelectContentState>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "list">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * A search field inside `SelectContent` that filters the list while focus stays in it. Put the items in a `SelectList`. Name it with `aria-label`.
+ * @stable
+ */
+declare const SelectInput: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/select").SelectInputState>>>, 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/select").SelectInputState>>>, "input">;
+/**
+ * Shown while no item matches the search. Its message is announced when it appears.
+ * @stable
+ */
+declare const SelectEmpty: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: NoInfer<{
+        loading: boolean;
+        empty: boolean;
+        query: string;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "empty">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * A polite live region for loading and result counts. Its content is yours, from its default slot's state.
+ * @stable
+ */
+declare const SelectStatus: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<{
+    status: AsyncOptionsStatus;
+    loading: boolean;
+    count: number;
+}>>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<{
+    status: AsyncOptionsStatus;
+    loading: boolean;
+    count: number;
+}>>>, "div">;
+/**
+ * An option. Pressing it selects it, or toggles it with `multiple`.
+ * @stable
+ */
+declare const SelectItem: new <A extends unknown = string>(props: import("@ui-sdk/core/select").SelectItemProps<A> & {} & 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;
+    onSelect?: ((payload: Event) => 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/select").SelectItemProps<A>, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/select").SelectItemState>>>, "div">;
+/**
+ * The check inside a selected item. Rendered while it's selected, or always with `keepMounted`.
+ * @stable
+ */
+declare const SelectItemIndicator: Pick<import("vue").DefineSetupFnComponent<Omit<NoInfer<import("@ui-sdk/core/select").SelectItemIndicatorProps & {
+    item?: string;
+}> & import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/select").SelectItemIndicatorState>>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<NoInfer<import("@ui-sdk/core/select").SelectItemIndicatorProps & {
+    item?: string;
+}> & import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/select").SelectItemIndicatorState>>>, "span">;
+/**
+ * The item's text, with the part the search matched in `<mark>`. Without text content, it shows the item's label.
+ * @stable
+ */
+declare const SelectItemText: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "item-text">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "span">;
+/**
+ * An option that selects every item that matches, with `multiple`: in its group inside a `SelectGroup`, or in the whole list.
+ * @stable
+ */
+declare const SelectSelectAll: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, (() => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: {
+        checked: boolean;
+        indeterminate: boolean;
+        highlighted: boolean;
+        disabled: boolean;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "select-all">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "div">;
+/**
+ * An icon inside an item. `SelectValueIcon` shows the selected item's in the trigger.
+ * Screen readers, typeahead and filtering
+ * skip it, and `mirror` flips it in right-to-left text.
+ * @stable
+ */
+declare const SelectItemIcon: import("./create-parts.js").ElementPart<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    mirror: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, (() => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | null) & {
+    state: {
+        mirror: boolean;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    mirror: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    mirror: boolean;
+}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "item-icon">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "span">;
+/**
+ * The selected item's icon, copied from its `SelectItemIcon`, like before the value in
+ * the trigger. Rendered while one item is selected and it has an icon.
+ * @stable
+ */
+declare const SelectValueIcon: import("./create-parts.js").ElementPart<import("vue").DefineComponent<{}, () => unknown, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, PartSlots<import("@ui-sdk/core/select").SelectPrimitive, "value-icon">, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, "span">;
+/**
+ * A group of items, named by its `SelectGroupLabel`, and hidden while none of its items shows.
+ * @stable
+ */
+declare const SelectGroup: 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 SelectGroupLabel: 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 SelectSeparator: 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">;
+/**
+ * A button that selects nothing. Shown while something is selected, or always with `keepMounted`.
+ * @stable
+ */
+declare const SelectClear: Pick<import("vue").DefineSetupFnComponent<Omit<NoInfer<import("@ui-sdk/core/select").SelectClearProps> & import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/select").SelectClearState>>>, never> & import("./create-parts.js").ElementConstructor<import("vue").DefineSetupFnComponent<Omit<NoInfer<import("@ui-sdk/core/select").SelectClearProps> & import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/select").SelectClearState>>>, "button">;
+/**
+ * An arrow on the popup's edge that points at the trigger.
+ * @stable
+ */
+declare const SelectArrow: Pick<import("vue").DefineSetupFnComponent<Omit<import("@ui-sdk/core/renderer").BaseSlotProps, never>, {} & {}, import("./use-primitive.js").StateSlots<NoInfer<import("@ui-sdk/core/select").SelectArrowState>>>, 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/select").SelectArrowState>>>, "div">;
+/**
+ * Renders data items. Used by data selects, and available for custom layouts.
+ * @stable
+ */
+declare const SelectItems: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    items: {
+        type: PropType<ListData<unknown>>;
+        required: true;
+    };
+}>, () => 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<ListData<unknown>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export { createSelectController } from "@ui-sdk/core/select";
+export type { ListAnnouncement, ListData, ListFilter, ListGroup, ListHighlightDetails, ListItem, ListSeparator, MatchSegment, SelectApi, SelectArrowState, SelectChangeOptions, SelectClearProps, SelectClearState, SelectContentProps, SelectContentState, SelectController, SelectDismissReason, SelectEmptyState, SelectInputState, SelectItemIconProps, SelectItemIconState, SelectItemIndicatorProps, SelectItemIndicatorState, SelectItemProps, SelectItemState, SelectItemTextState, SelectOpenChangeReason, SelectOptions, SelectPrimitive, SelectQueryChangeReason, SelectSelectAllState, SelectStatusState, SelectTriggerProps, SelectTriggerState, SelectValue as SelectValueData, SelectValueChangeReason, SelectValueProps, SelectValueState, } from "@ui-sdk/core/select";
+export { Select, SelectArrow, SelectClear, SelectContent, SelectEmpty, SelectGroup, SelectGroupLabel, SelectInput, SelectItem, SelectItemIcon, SelectItemIndicator, SelectItems, SelectItemText, SelectLabel, SelectList, SelectSelectAll, SelectSeparator, SelectStatus, SelectTrigger, SelectValue, SelectValueIcon, };