reka-ui
Version:
Vue port for Radix UI Primitives.
1,099 lines (1,097 loc) • 495 kB
TypeScript
import { Grid, Matcher, WeekDayFormat, WeekStartsOn } from "./index2.js";
import { AcceptableValue, DataOrientation, DateRange, DateStep, Direction, FormFieldProps, Formatter, Granularity, HourCycle, ScrollBodyOption, SegmentPart, SegmentValueObj, SingleOrMultipleProps, SingleOrMultipleType, StringOrNumber, TimeRange, TimeValue, useSelectionBehavior } from "./index3.js";
import * as vue60 from "vue";
import { CSSProperties, Component, ComputedRef, HTMLAttributes, ImgHTMLAttributes, MaybeRefOrGetter, PropType, Ref, SlotsType, VNode, VNodeRef } from "vue";
import { EventHook, EventHookOn } from "@vueuse/core";
import * as _internationalized_date458 from "@internationalized/date";
import { DateValue } from "@internationalized/date";
import { VirtualItem, Virtualizer } from "@tanstack/vue-virtual";
import { ReferenceElement, ReferenceElement as ReferenceElement$1 } from "@floating-ui/vue";
//#region src/Primitive/Primitive.d.ts
type AsTag = 'a' | 'button' | 'div' | 'form' | 'h2' | 'h3' | 'img' | 'input' | 'label' | 'li' | 'nav' | 'ol' | 'p' | 'span' | 'svg' | 'ul' | 'template' | ({} & string);
interface PrimitiveProps {
/**
* Change the default rendered element for the one passed as a child, merging their props and behavior.
*
* Read our [Composition](https://www.reka-ui.com/docs/guides/composition) guide for more details.
*/
asChild?: boolean;
/**
* The element or component this component should render as. Can be overwritten by `asChild`.
* @defaultValue "div"
*/
as?: AsTag | Component;
}
declare const Primitive: vue60.DefineComponent<vue60.ExtractPropTypes<{
asChild: {
type: BooleanConstructor;
default: boolean;
};
as: {
type: PropType<AsTag | Component>;
default: string;
};
}>, () => vue60.VNode<vue60.RendererNode, vue60.RendererElement, {
[key: string]: any;
}>, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<vue60.ExtractPropTypes<{
asChild: {
type: BooleanConstructor;
default: boolean;
};
as: {
type: PropType<AsTag | Component>;
default: string;
};
}>> & Readonly<{}>, {
asChild: boolean;
as: AsTag | Component;
}, {}, {}, {}, string, vue60.ComponentProvideOptions, true, {}, any>;
//# sourceMappingURL=Primitive.d.ts.map
//#endregion
//#region src/Primitive/Slot.d.ts
declare const Slot: vue60.DefineComponent<{}, () => vue60.VNode<vue60.RendererNode, vue60.RendererElement, {
[key: string]: any;
}> | vue60.VNode<vue60.RendererNode, vue60.RendererElement, {
[key: string]: any;
}>[] | null, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, true, {}, any>;
//# sourceMappingURL=Slot.d.ts.map
//#endregion
//#region src/Collapsible/CollapsibleContent.vue.d.ts
interface CollapsibleContentProps extends PrimitiveProps {
/**
* Used to force mounting when more control is needed. Useful when
* controlling animation with Vue animation libraries.
*/
forceMount?: boolean;
}
type CollapsibleContentEmits = {
contentFound: [void];
};
declare const _default$378: typeof __VLS_export$377;
declare const __VLS_export$377: __VLS_WithSlots$359<vue60.DefineComponent<CollapsibleContentProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
contentFound: (args_0: void) => any;
}, string, vue60.PublicProps, Readonly<CollapsibleContentProps> & Readonly<{
onContentFound?: ((args_0?: void | undefined) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$359<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=CollapsibleContent.vue.d.ts.map
//#endregion
//#region src/Collapsible/CollapsibleRoot.vue.d.ts
interface CollapsibleRootProps extends PrimitiveProps {
/** The open state of the collapsible when it is initially rendered. <br> Use when you do not need to control its open state. */
defaultOpen?: boolean;
/** The controlled open state of the collapsible. Can be binded with `v-model`. */
open?: boolean;
/** When `true`, prevents the user from interacting with the collapsible. */
disabled?: boolean;
/** When `true`, the element will be unmounted on closed state. */
unmountOnHide?: boolean;
}
type CollapsibleRootEmits = {
/** Event handler called when the open state of the collapsible changes. */
'update:open': [value: boolean];
};
interface CollapsibleRootContext {
contentId: string;
disabled?: Ref<boolean>;
open: Ref<boolean>;
unmountOnHide: Ref<boolean>;
onOpenToggle: () => void;
}
declare const injectCollapsibleRootContext: <T extends CollapsibleRootContext | null | undefined = CollapsibleRootContext>(fallback?: T | undefined) => T extends null ? CollapsibleRootContext | null : CollapsibleRootContext, provideCollapsibleRootContext: (contextValue: CollapsibleRootContext) => CollapsibleRootContext;
declare const _default$377: typeof __VLS_export$376;
declare const __VLS_export$376: __VLS_WithSlots$358<vue60.DefineComponent<CollapsibleRootProps, {
open: Ref<boolean, boolean>;
}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, vue60.PublicProps, Readonly<CollapsibleRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current open state */
open: boolean;
}) => any;
}>;
type __VLS_WithSlots$358<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=CollapsibleRoot.vue.d.ts.map
//#endregion
//#region src/Collapsible/CollapsibleTrigger.vue.d.ts
interface CollapsibleTriggerProps extends PrimitiveProps {}
declare const _default$376: typeof __VLS_export$375;
declare const __VLS_export$375: __VLS_WithSlots$357<vue60.DefineComponent<CollapsibleTriggerProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<CollapsibleTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$357<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=CollapsibleTrigger.vue.d.ts.map
//#endregion
//#region src/Accordion/AccordionContent.vue.d.ts
interface AccordionContentProps extends CollapsibleContentProps {}
declare const _default$375: typeof __VLS_export$374;
declare const __VLS_export$374: __VLS_WithSlots$356<vue60.DefineComponent<AccordionContentProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AccordionContentProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$356<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AccordionContent.vue.d.ts.map
//#endregion
//#region src/Accordion/AccordionHeader.vue.d.ts
interface AccordionHeaderProps extends PrimitiveProps {}
declare const _default$374: typeof __VLS_export$373;
declare const __VLS_export$373: __VLS_WithSlots$355<vue60.DefineComponent<AccordionHeaderProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AccordionHeaderProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$355<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AccordionHeader.vue.d.ts.map
//#endregion
//#region src/Accordion/AccordionItem.vue.d.ts
declare enum AccordionItemState {
Open = "open",
Closed = "closed",
}
interface AccordionItemProps extends Omit<CollapsibleRootProps, 'open' | 'defaultOpen' | 'onOpenChange'> {
/**
* Whether or not an accordion item is disabled from user interaction.
* When `true`, prevents the user from interacting with the item.
*
* @defaultValue false
*/
disabled?: boolean;
/**
* A string value for the accordion item. All items within an accordion should use a unique value.
*/
value: string;
}
interface AccordionItemContext {
open: ComputedRef<boolean>;
dataState: ComputedRef<AccordionItemState>;
disabled: ComputedRef<boolean>;
dataDisabled: ComputedRef<'' | undefined>;
triggerId: string;
currentRef: VNodeRef;
currentElement: ComputedRef<HTMLElement | undefined>;
value: ComputedRef<string>;
}
declare const injectAccordionItemContext: <T extends AccordionItemContext | null | undefined = AccordionItemContext>(fallback?: T | undefined) => T extends null ? AccordionItemContext | null : AccordionItemContext, provideAccordionItemContext: (contextValue: AccordionItemContext) => AccordionItemContext;
declare const _default$373: typeof __VLS_export$372;
declare const __VLS_export$372: __VLS_WithSlots$354<vue60.DefineComponent<AccordionItemProps, {
open: ComputedRef<boolean>;
dataDisabled: ComputedRef<"" | undefined>;
}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AccordionItemProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current open state */
open: boolean;
}) => any;
}>;
type __VLS_WithSlots$354<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AccordionItem.vue.d.ts.map
//#endregion
//#region src/Accordion/AccordionRoot.vue.d.ts
interface AccordionRootProps<T = string | string[]> extends PrimitiveProps, SingleOrMultipleProps<T> {
/**
* When type is "single", allows closing content when clicking trigger for an open item.
* When type is "multiple", this prop has no effect.
*
* @defaultValue false
*/
collapsible?: boolean;
/**
* When `true`, prevents the user from interacting with the accordion and all its items
*
* @defaultValue false
*/
disabled?: boolean;
/**
* The reading direction of the accordion when applicable. If omitted, assumes LTR (left-to-right) reading mode.
*
* @defaultValue "ltr"
*/
dir?: Direction;
/**
* The orientation of the accordion.
*
* @defaultValue "vertical"
*/
orientation?: DataOrientation;
/**
* When `true`, the element will be unmounted on closed state.
*
* @defaultValue `true`
*/
unmountOnHide?: boolean;
}
type AccordionRootEmits<T extends SingleOrMultipleType = SingleOrMultipleType> = {
/**
* Event handler called when the expanded state of an item changes
*/
'update:modelValue': [value: (T extends 'single' ? string : string[]) | undefined];
};
type AccordionRootContext<P extends AccordionRootProps> = {
disabled: Ref<P['disabled']>;
direction: Ref<P['dir']>;
orientation: P['orientation'];
parentElement: Ref<HTMLElement | undefined>;
changeModelValue: (value: string) => void;
isSingle: ComputedRef<boolean>;
modelValue: Ref<AcceptableValue | AcceptableValue[] | undefined>;
collapsible: boolean;
unmountOnHide: Ref<boolean>;
};
declare const injectAccordionRootContext: <T extends AccordionRootContext<AccordionRootProps<string | string[]>> | null | undefined = AccordionRootContext<AccordionRootProps<string | string[]>>>(fallback?: T | undefined) => T extends null ? AccordionRootContext<AccordionRootProps<string | string[]>> | null : AccordionRootContext<AccordionRootProps<string | string[]>>, provideAccordionRootContext: (contextValue: AccordionRootContext<AccordionRootProps<string | string[]>>) => AccordionRootContext<AccordionRootProps<string | string[]>>;
declare const _default$372: typeof __VLS_export$371;
declare const __VLS_export$371: <T extends (string | string[]), ExplicitType extends SingleOrMultipleType>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$16<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
props: vue60.PublicProps & __VLS_PrettifyLocal$16<AccordionRootProps<T> & {
"onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | undefined;
}> & (typeof globalThis extends {
__VLS_PROPS_FALLBACK: infer P;
} ? P : {});
expose: (exposed: {}) => void;
attrs: any;
slots: {
default?: (props: {
/** Current active value */
modelValue: AcceptableValue | AcceptableValue[] | undefined;
}) => any;
};
emit: (evt: "update:modelValue", value: (ExplicitType extends "single" ? string : string[]) | undefined) => void;
}>) => vue60.VNode & {
__ctx?: Awaited<typeof __VLS_setup>;
};
type __VLS_PrettifyLocal$16<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
//# sourceMappingURL=AccordionRoot.vue.d.ts.map
//#endregion
//#region src/Accordion/AccordionTrigger.vue.d.ts
interface AccordionTriggerProps extends PrimitiveProps {}
declare const _default$371: typeof __VLS_export$370;
declare const __VLS_export$370: __VLS_WithSlots$353<vue60.DefineComponent<AccordionTriggerProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AccordionTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$353<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AccordionTrigger.vue.d.ts.map
//#endregion
//#region src/Dialog/DialogClose.vue.d.ts
interface DialogCloseProps extends PrimitiveProps {}
declare const _default$370: typeof __VLS_export$369;
declare const __VLS_export$369: __VLS_WithSlots$352<vue60.DefineComponent<DialogCloseProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$352<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=DialogClose.vue.d.ts.map
//#endregion
//#region src/DismissableLayer/utils.d.ts
type PointerDownOutsideEvent = CustomEvent<{
originalEvent: PointerEvent;
}>;
type FocusOutsideEvent = CustomEvent<{
originalEvent: FocusEvent;
}>;
//#endregion
//#region src/DismissableLayer/DismissableLayer.vue.d.ts
interface DismissableLayerProps extends PrimitiveProps {
/**
* When `true`, hover/focus/click interactions will be disabled on elements outside
* the `DismissableLayer`. Users will need to click twice on outside elements to
* interact with them: once to close the `DismissableLayer`, and again to trigger the element.
*/
disableOutsidePointerEvents?: boolean;
}
type DismissableLayerEmits = {
/**
* Event handler called when the escape key is down.
* Can be prevented.
*/
escapeKeyDown: [event: KeyboardEvent];
/**
* Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`.
* Can be prevented.
*/
pointerDownOutside: [event: PointerDownOutsideEvent];
/**
* Event handler called when the focus moves outside of the `DismissableLayer`.
* Can be prevented.
*/
focusOutside: [event: FocusOutsideEvent];
/**
* Event handler called when an interaction happens outside the `DismissableLayer`.
* Specifically, when a `pointerdown` event happens outside or focus moves outside of it.
* Can be prevented.
*/
interactOutside: [event: PointerDownOutsideEvent | FocusOutsideEvent];
};
//#endregion
//#region src/Dialog/DialogContentImpl.vue.d.ts
type DialogContentImplEmits = DismissableLayerEmits & {
/**
* Event handler called when auto-focusing on open.
* Can be prevented.
*/
openAutoFocus: [event: Event];
/**
* Event handler called when auto-focusing on close.
* Can be prevented.
*/
closeAutoFocus: [event: Event];
};
interface DialogContentImplProps extends DismissableLayerProps {
/**
* Used to force mounting when more control is needed. Useful when
* controlling transntion with Vue native transition or other animation libraries.
*/
forceMount?: boolean;
/**
* When `true`, focus cannot escape the `Content` via keyboard,
* pointer, or a programmatic focus.
* @defaultValue false
*/
trapFocus?: boolean;
}
//#endregion
//#region src/Dialog/DialogContent.vue.d.ts
type DialogContentEmits = DialogContentImplEmits;
interface DialogContentProps extends Omit<DialogContentImplProps, 'trapFocus'> {
/**
* Used to force mounting when more control is needed. Useful when
* controlling animation with Vue animation libraries.
*/
forceMount?: boolean;
}
declare const _default$369: typeof __VLS_export$368;
declare const __VLS_export$368: __VLS_WithSlots$351<vue60.DefineComponent<DialogContentProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, vue60.PublicProps, Readonly<DialogContentProps> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
} & {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$351<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=DialogContent.vue.d.ts.map
//#endregion
//#region src/Dialog/DialogDescription.vue.d.ts
interface DialogDescriptionProps extends PrimitiveProps {}
declare const _default$368: typeof __VLS_export$367;
declare const __VLS_export$367: __VLS_WithSlots$350<vue60.DefineComponent<DialogDescriptionProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<DialogDescriptionProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$350<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=DialogDescription.vue.d.ts.map
//#endregion
//#region src/Dialog/DialogOverlayImpl.vue.d.ts
interface DialogOverlayImplProps extends PrimitiveProps {}
//#endregion
//#region src/Dialog/DialogOverlay.vue.d.ts
interface DialogOverlayProps extends DialogOverlayImplProps {
/**
* Used to force mounting when more control is needed. Useful when
* controlling animation with Vue animation libraries.
*/
forceMount?: boolean;
}
declare const _default$367: typeof __VLS_export$366;
declare const __VLS_export$366: __VLS_WithSlots$349<vue60.DefineComponent<DialogOverlayProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<DialogOverlayProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$349<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=DialogOverlay.vue.d.ts.map
//#endregion
//#region src/Teleport/Teleport.vue.d.ts
interface TeleportProps {
/**
* Vue native teleport component prop `:to`
*
* {@link https://vuejs.org/guide/built-ins/teleport.html#basic-usage}
*/
to?: string | HTMLElement;
/**
* Disable teleport and render the component inline
*
* {@link https://vuejs.org/guide/built-ins/teleport.html#disabling-teleport}
*/
disabled?: boolean;
/**
* Defer the resolving of a Teleport target until other parts of the
* application have mounted (requires Vue 3.5.0+)
*
* {@link https://vuejs.org/guide/built-ins/teleport.html#deferred-teleport}
*/
defer?: boolean;
/**
* Used to force mounting when more control is needed. Useful when
* controlling animation with Vue animation libraries.
*/
forceMount?: boolean;
}
//#endregion
//#region src/Dialog/DialogPortal.vue.d.ts
interface DialogPortalProps extends TeleportProps {}
declare const _default$366: typeof __VLS_export$365;
declare const __VLS_export$365: __VLS_WithSlots$348<vue60.DefineComponent<DialogPortalProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<DialogPortalProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$348<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=DialogPortal.vue.d.ts.map
//#endregion
//#region src/Dialog/DialogRoot.vue.d.ts
interface DialogRootProps {
/** The controlled open state of the dialog. Can be binded as `v-model:open`. */
open?: boolean;
/** The open state of the dialog when it is initially rendered. Use when you do not need to control its open state. */
defaultOpen?: boolean;
/**
* The modality of the dialog When set to `true`, <br>
* interaction with outside elements will be disabled and only dialog content will be visible to screen readers.
*/
modal?: boolean;
}
type DialogRootEmits = {
/** Event handler called when the open state of the dialog changes. */
'update:open': [value: boolean];
};
interface DialogRootContext {
open: Readonly<Ref<boolean>>;
modal: Ref<boolean>;
openModal: () => void;
onOpenChange: (value: boolean) => void;
onOpenToggle: () => void;
triggerElement: Ref<HTMLElement | undefined>;
contentElement: Ref<HTMLElement | undefined>;
contentId: string;
titleId: string;
descriptionId: string;
}
declare const injectDialogRootContext: <T extends DialogRootContext | null | undefined = DialogRootContext>(fallback?: T | undefined) => T extends null ? DialogRootContext | null : DialogRootContext, provideDialogRootContext: (contextValue: DialogRootContext) => DialogRootContext;
declare const _default$365: typeof __VLS_export$364;
declare const __VLS_export$364: __VLS_WithSlots$347<vue60.DefineComponent<DialogRootProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, vue60.PublicProps, Readonly<DialogRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current open state */
open: boolean;
/** Close the dialog */
close: () => void;
}) => any;
}>;
type __VLS_WithSlots$347<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=DialogRoot.vue.d.ts.map
//#endregion
//#region src/Dialog/DialogTitle.vue.d.ts
interface DialogTitleProps extends PrimitiveProps {}
declare const _default$364: typeof __VLS_export$363;
declare const __VLS_export$363: __VLS_WithSlots$346<vue60.DefineComponent<DialogTitleProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<DialogTitleProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$346<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=DialogTitle.vue.d.ts.map
//#endregion
//#region src/Dialog/DialogTrigger.vue.d.ts
interface DialogTriggerProps extends PrimitiveProps {}
declare const _default$363: typeof __VLS_export$362;
declare const __VLS_export$362: __VLS_WithSlots$345<vue60.DefineComponent<DialogTriggerProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<DialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$345<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=DialogTrigger.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogAction.vue.d.ts
interface AlertDialogActionProps extends DialogCloseProps {}
declare const _default$362: typeof __VLS_export$361;
declare const __VLS_export$361: __VLS_WithSlots$344<vue60.DefineComponent<AlertDialogActionProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AlertDialogActionProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$344<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogAction.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogCancel.vue.d.ts
interface AlertDialogCancelProps extends DialogCloseProps {}
declare const _default$361: typeof __VLS_export$360;
declare const __VLS_export$360: __VLS_WithSlots$343<vue60.DefineComponent<AlertDialogCancelProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AlertDialogCancelProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$343<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogCancel.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogContent.vue.d.ts
interface AlertDialogContentContext {
onCancelElementChange: (el: HTMLElement | undefined) => void;
}
declare const injectAlertDialogContentContext: <T extends AlertDialogContentContext | null | undefined = AlertDialogContentContext>(fallback?: T | undefined) => T extends null ? AlertDialogContentContext | null : AlertDialogContentContext, provideAlertDialogContentContext: (contextValue: AlertDialogContentContext) => AlertDialogContentContext;
type AlertDialogContentEmits = DialogContentEmits;
interface AlertDialogContentProps extends DialogContentProps {}
declare const _default$360: typeof __VLS_export$359;
declare const __VLS_export$359: __VLS_WithSlots$342<vue60.DefineComponent<AlertDialogContentProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
openAutoFocus: (event: Event) => any;
closeAutoFocus: (event: Event) => any;
}, string, vue60.PublicProps, Readonly<AlertDialogContentProps> & Readonly<{
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$342<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogContent.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogDescription.vue.d.ts
interface AlertDialogDescriptionProps extends DialogDescriptionProps {}
declare const _default$359: typeof __VLS_export$358;
declare const __VLS_export$358: __VLS_WithSlots$341<vue60.DefineComponent<AlertDialogDescriptionProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AlertDialogDescriptionProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$341<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogDescription.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogOverlay.vue.d.ts
interface AlertDialogOverlayProps extends DialogOverlayProps {}
declare const _default$358: typeof __VLS_export$357;
declare const __VLS_export$357: __VLS_WithSlots$340<vue60.DefineComponent<AlertDialogOverlayProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AlertDialogOverlayProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$340<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogOverlay.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogPortal.vue.d.ts
interface AlertDialogPortalProps extends TeleportProps {}
declare const _default$357: typeof __VLS_export$356;
declare const __VLS_export$356: __VLS_WithSlots$339<vue60.DefineComponent<AlertDialogPortalProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AlertDialogPortalProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$339<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogPortal.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogRoot.vue.d.ts
type AlertDialogEmits = DialogRootEmits;
interface AlertDialogProps extends Omit<DialogRootProps, 'modal'> {}
declare const _default$356: typeof __VLS_export$355;
declare const __VLS_export$355: __VLS_WithSlots$338<vue60.DefineComponent<AlertDialogProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, vue60.PublicProps, Readonly<AlertDialogProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
open: boolean;
close: () => void;
}) => any;
}>;
type __VLS_WithSlots$338<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogRoot.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogTitle.vue.d.ts
interface AlertDialogTitleProps extends DialogTitleProps {}
declare const _default$355: typeof __VLS_export$354;
declare const __VLS_export$354: __VLS_WithSlots$337<vue60.DefineComponent<AlertDialogTitleProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AlertDialogTitleProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$337<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogTitle.vue.d.ts.map
//#endregion
//#region src/AlertDialog/AlertDialogTrigger.vue.d.ts
interface AlertDialogTriggerProps extends DialogTriggerProps {}
declare const _default$354: typeof __VLS_export$353;
declare const __VLS_export$353: __VLS_WithSlots$336<vue60.DefineComponent<AlertDialogTriggerProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AlertDialogTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$336<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AlertDialogTrigger.vue.d.ts.map
//#endregion
//#region src/AspectRatio/AspectRatio.vue.d.ts
interface AspectRatioProps extends PrimitiveProps {
/**
* The desired ratio. Eg: 16/9
* @defaultValue 1
*/
ratio?: number;
}
declare const _default$353: typeof __VLS_export$352;
declare const __VLS_export$352: __VLS_WithSlots$335<vue60.DefineComponent<AspectRatioProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<AspectRatioProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current aspect ratio (in %) */
aspect: number;
}) => any;
}>;
type __VLS_WithSlots$335<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AspectRatio.vue.d.ts.map
//#endregion
//#region src/Listbox/ListboxContent.vue.d.ts
interface ListboxContentProps extends PrimitiveProps {}
declare const _default$352: typeof __VLS_export$351;
declare const __VLS_export$351: __VLS_WithSlots$334<vue60.DefineComponent<ListboxContentProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<ListboxContentProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$334<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=ListboxContent.vue.d.ts.map
//#endregion
//#region src/Listbox/ListboxFilter.vue.d.ts
interface ListboxFilterProps extends PrimitiveProps {
/** The controlled value of the filter. Can be binded with v-model. */
modelValue?: string;
/** Focus on element when mounted. */
autoFocus?: boolean;
/** When `true`, prevents the user from interacting with item */
disabled?: boolean;
}
type ListboxFilterEmits = {
'update:modelValue': [string];
};
declare const _default$351: typeof __VLS_export$350;
declare const __VLS_export$350: __VLS_WithSlots$333<vue60.DefineComponent<ListboxFilterProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
"update:modelValue": (args_0: string) => any;
}, string, vue60.PublicProps, Readonly<ListboxFilterProps> & Readonly<{
"onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current input values */
modelValue: string | undefined;
}) => any;
}>;
type __VLS_WithSlots$333<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=ListboxFilter.vue.d.ts.map
//#endregion
//#region src/Listbox/ListboxGroup.vue.d.ts
interface ListboxGroupProps extends PrimitiveProps {}
interface ListboxGroupContext {
id: string;
}
declare const injectListboxGroupContext: <T extends ListboxGroupContext | null | undefined = ListboxGroupContext>(fallback?: T | undefined) => T extends null ? ListboxGroupContext | null : ListboxGroupContext, provideListboxGroupContext: (contextValue: ListboxGroupContext) => ListboxGroupContext;
declare const _default$350: typeof __VLS_export$349;
declare const __VLS_export$349: __VLS_WithSlots$332<vue60.DefineComponent<ListboxGroupProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<ListboxGroupProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$332<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=ListboxGroup.vue.d.ts.map
//#endregion
//#region src/Listbox/ListboxGroupLabel.vue.d.ts
interface ListboxGroupLabelProps extends PrimitiveProps {
for?: string;
}
declare const _default$349: typeof __VLS_export$348;
declare const __VLS_export$348: __VLS_WithSlots$331<vue60.DefineComponent<ListboxGroupLabelProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<ListboxGroupLabelProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$331<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=ListboxGroupLabel.vue.d.ts.map
//#endregion
//#region src/Listbox/ListboxItem.vue.d.ts
interface ListboxItemProps<T = AcceptableValue> extends PrimitiveProps {
/** The value given as data when submitted with a `name`. */
value: T;
/** When `true`, prevents the user from interacting with the item. */
disabled?: boolean;
}
type SelectEvent$3<T> = CustomEvent<{
originalEvent: PointerEvent;
value?: T;
}>;
type ListboxItemEmits<T = AcceptableValue> = {
/** Event handler called when the selecting item. <br> It can be prevented by calling `event.preventDefault`. */
select: [event: SelectEvent$3<T>];
};
interface ListboxItemContext {
isSelected: Ref<boolean>;
}
declare const injectListboxItemContext: <T extends ListboxItemContext | null | undefined = ListboxItemContext>(fallback?: T | undefined) => T extends null ? ListboxItemContext | null : ListboxItemContext, provideListboxItemContext: (contextValue: ListboxItemContext) => ListboxItemContext;
declare const _default$348: typeof __VLS_export$347;
declare const __VLS_export$347: <T extends AcceptableValue = AcceptableValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$15<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
props: vue60.PublicProps & __VLS_PrettifyLocal$15<ListboxItemProps<T> & {
onSelect?: ((event: SelectEvent$3<T>) => any) | undefined;
}> & (typeof globalThis extends {
__VLS_PROPS_FALLBACK: infer P;
} ? P : {});
expose: (exposed: {}) => void;
attrs: any;
slots: {
default?: (props: {}) => any;
};
emit: (evt: "select", event: SelectEvent$3<T>) => void;
}>) => vue60.VNode & {
__ctx?: Awaited<typeof __VLS_setup>;
};
type __VLS_PrettifyLocal$15<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
//# sourceMappingURL=ListboxItem.vue.d.ts.map
//#endregion
//#region src/Listbox/ListboxItemIndicator.vue.d.ts
interface ListboxItemIndicatorProps extends PrimitiveProps {}
declare const _default$347: typeof __VLS_export$346;
declare const __VLS_export$346: __VLS_WithSlots$330<vue60.DefineComponent<ListboxItemIndicatorProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {}, string, vue60.PublicProps, Readonly<ListboxItemIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$330<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=ListboxItemIndicator.vue.d.ts.map
//#endregion
//#region src/Listbox/ListboxRoot.vue.d.ts
type ListboxRootContext<T> = {
modelValue: Ref<T | Array<T> | undefined>;
onValueChange: (val: T) => void;
multiple: Ref<boolean>;
orientation: Ref<DataOrientation>;
dir: Ref<Direction>;
disabled: Ref<boolean>;
highlightOnHover: Ref<boolean>;
highlightedElement: Ref<HTMLElement | null>;
isVirtual: Ref<boolean>;
virtualFocusHook: EventHook<Event | null | undefined>;
virtualKeydownHook: EventHook<KeyboardEvent>;
virtualHighlightHook: EventHook<any>;
by?: string | ((a: T, b: T) => boolean);
firstValue?: Ref<T | undefined>;
selectionBehavior?: Ref<'toggle' | 'replace'>;
focusable: Ref<boolean>;
onLeave: (event: Event) => void;
onEnter: (event: Event) => void;
changeHighlight: (el: HTMLElement, scrollIntoView?: boolean, focus?: boolean) => void;
onKeydownNavigation: (event: KeyboardEvent) => void;
onKeydownEnter: (event: KeyboardEvent) => void;
onKeydownTypeAhead: (event: KeyboardEvent) => void;
onCompositionStart: () => void;
onCompositionEnd: () => void;
highlightFirstItem: () => void;
};
declare const injectListboxRootContext: <T extends ListboxRootContext<AcceptableValue> | null | undefined = ListboxRootContext<AcceptableValue>>(fallback?: T | undefined) => T extends null ? ListboxRootContext<AcceptableValue> | null : ListboxRootContext<AcceptableValue>, provideListboxRootContext: (contextValue: ListboxRootContext<AcceptableValue>) => ListboxRootContext<AcceptableValue>;
interface ListboxRootProps<T = AcceptableValue> extends PrimitiveProps, FormFieldProps {
/** The controlled value of the listbox. Can be binded with `v-model`. */
modelValue?: T | Array<T>;
/** The value of the listbox when initially rendered. Use when you do not need to control the state of the Listbox */
defaultValue?: T | Array<T>;
/** Whether multiple options can be selected or not. */
multiple?: boolean;
/** The orientation of the listbox. <br>Mainly so arrow navigation is done accordingly (left & right vs. up & down) */
orientation?: DataOrientation;
/** The reading direction of the listbox when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
dir?: Direction;
/** When `true`, prevents the user from interacting with listbox */
disabled?: boolean;
/**
* How multiple selection should behave in the collection.
* @defaultValue 'toggle'
*/
selectionBehavior?: 'toggle' | 'replace';
/** When `true`, hover over item will trigger highlight */
highlightOnHover?: boolean;
/** Use this to compare objects by a particular field, or pass your own comparison function for complete control over how objects are compared. */
by?: string | ((a: T, b: T) => boolean);
}
type ListboxRootEmits<T = AcceptableValue> = {
/** Event handler called when the value changes. */
'update:modelValue': [value: T];
/** Event handler when highlighted element changes. */
'highlight': [payload: {
ref: HTMLElement;
value: T;
} | undefined];
/** Event handler called when container is being focused. Can be prevented. */
'entryFocus': [event: CustomEvent];
/** Event handler called when the mouse leave the container */
'leave': [event: Event];
};
declare const _default$346: typeof __VLS_export$345;
declare const __VLS_export$345: <T extends AcceptableValue = AcceptableValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$14<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
props: vue60.PublicProps & __VLS_PrettifyLocal$14<ListboxRootProps<AcceptableValue> & {
"onUpdate:modelValue"?: ((value: AcceptableValue) => any) | undefined;
onEntryFocus?: ((event: CustomEvent<any>) => any) | undefined;
onHighlight?: ((payload: {
ref: HTMLElement;
value: AcceptableValue;
} | undefined) => any) | undefined;
onLeave?: ((event: Event) => any) | undefined;
}> & (typeof globalThis extends {
__VLS_PROPS_FALLBACK: infer P;
} ? P : {});
expose: (exposed: vue60.ShallowUnwrapRef<{
highlightedElement: Ref<HTMLElement | null, HTMLElement | null>;
highlightItem: (value: T) => void;
highlightFirstItem: () => void;
highlightSelected: (event?: Event) => Promise<void>;
getItems: (includeDisabledItem?: boolean) => ({
ref: HTMLElement;
value?: any;
} & {
value: T;
})[];
}>) => void;
attrs: any;
slots: {
default?: (props: {
/** Current active value */
modelValue: T | T[] | undefined;
}) => any;
};
emit: ((evt: "update:modelValue", value: AcceptableValue) => void) & ((evt: "entryFocus", event: CustomEvent<any>) => void) & ((evt: "highlight", payload: {
ref: HTMLElement;
value: AcceptableValue;
} | undefined) => void) & ((evt: "leave", event: Event) => void);
}>) => vue60.VNode & {
__ctx?: Awaited<typeof __VLS_setup>;
};
type __VLS_PrettifyLocal$14<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
//# sourceMappingURL=ListboxRoot.vue.d.ts.map
//#endregion
//#region src/Listbox/ListboxVirtualizer.vue.d.ts
interface ListboxVirtualizerProps<T extends AcceptableValue = AcceptableValue> {
/** List of items */
options: T[];
/** Number of items rendered outside the visible area */
overscan?: number;
/** Estimated size (in px) of each item */
estimateSize?: number | ((index: number) => number);
/** Text content for each item to achieve type-ahead feature */
textContent?: (option: T) => string;
}
declare const _default$345: typeof __VLS_export$344;
declare const __VLS_export$344: <T extends AcceptableValue = AcceptableValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$13<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
props: vue60.PublicProps & __VLS_PrettifyLocal$13<ListboxVirtualizerProps<T>> & (typeof globalThis extends {
__VLS_PROPS_FALLBACK: infer P;
} ? P : {});
expose: (exposed: {}) => void;
attrs: any;
slots: {
default?: (props: {
option: T;
virtualizer: Virtualizer<HTMLElement, Element>;
virtualItem: VirtualItem;
}) => any;
};
emit: {};
}>) => vue60.VNode & {
__ctx?: Awaited<typeof __VLS_setup>;
};
type __VLS_PrettifyLocal$13<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
//# sourceMappingURL=ListboxVirtualizer.vue.d.ts.map
//#endregion
//#region src/Autocomplete/AutocompleteInput.vue.d.ts
type AutocompleteInputEmits = ListboxFilterEmits;
interface AutocompleteInputProps extends ListboxFilterProps {}
declare const _default$344: typeof __VLS_export$343;
declare const __VLS_export$343: __VLS_WithSlots$329<vue60.DefineComponent<AutocompleteInputProps, {}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
"update:modelValue": (args_0: string) => any;
}, string, vue60.PublicProps, Readonly<AutocompleteInputProps> & Readonly<{
"onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$329<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AutocompleteInput.vue.d.ts.map
//#endregion
//#region src/Autocomplete/AutocompleteRoot.vue.d.ts
interface AutocompleteRootProps extends PrimitiveProps {
/** The controlled value of the Autocomplete (the input text). Can be bound with `v-model`. */
modelValue?: string;
/** The value of the autocomplete when initially rendered. Use when you do not need to control the state. */
defaultValue?: string;
/** The controlled open state of the Autocomplete. Can be bound with `v-model:open`. */
open?: boolean;
/** The open state of the autocomplete when it is initially rendered. Use when you do not need to control its open state. */
defaultOpen?: boolean;
/** When `true`, prevents the user from interacting with autocomplete */
disabled?: boolean;
/** The reading direction of the autocomplete when applicable. */
dir?: Direction;
/** The name of the field. Submitted with its owning form as part of a name/value pair. */
name?: string;
/** When `true`, indicates that the user must set the value before the owning form can be submitted. */
required?: boolean;
/**
* Whether to reset the searchTerm when the Autocomplete input blurred
* @defaultValue `false`
*/
resetSearchTermOnBlur?: boolean;
/**
* Whether to open the autocomplete when the input is focused
* @defaultValue `false`
*/
openOnFocus?: boolean;
/**
* Whether to open the autocomplete when the input is clicked
* @defaultValue `false`
*/
openOnClick?: boolean;
/**
* When `true`, disable the default filters
*/
ignoreFilter?: boolean;
/** When `true`, hover over item will trigger highlight */
highlightOnHover?: boolean;
}
type AutocompleteRootEmits = {
/** Event handler called when the value changes. */
'update:modelValue': [value: string];
/** Event handler when highlighted element changes. */
'highlight': [payload: {
ref: HTMLElement;
value: string;
} | undefined];
/** Event handler called when the open state of the autocomplete changes. */
'update:open': [value: boolean];
};
type AutocompleteRootContext = {
modelValue: Ref<string>;
};
declare const injectAutocompleteRootContext: <T extends AutocompleteRootContext | null | undefined = AutocompleteRootContext>(fallback?: T | undefined) => T extends null ? AutocompleteRootContext | null : AutocompleteRootContext, provideAutocompleteRootContext: (contextValue: AutocompleteRootContext) => AutocompleteRootContext;
declare const _default$343: typeof __VLS_export$342;
declare const __VLS_export$342: __VLS_WithSlots$328<vue60.DefineComponent<AutocompleteRootProps, {
filtered: vue60.ComputedRef<{
count: number;
items: Map<string, number>;
groups: Set<string>;
}>;
highlightedElement: vue60.ComputedRef<HTMLElement | undefined>;
highlightItem: ((value: AcceptableValue) => void) | undefined;
highlightFirstItem: (() => void) | undefined;
highlightSelected: ((event?: Event) => Promise<void>) | undefined;
}, {}, {}, {}, vue60.ComponentOptionsMixin, vue60.ComponentOptionsMixin, {
"update:modelValue": (value: string) => any;
"update:open": (value: boolean) => any;
highlight: (payload: {
ref: HTMLElement;
value: string;
} | undefined) => any;
}, string, vue60.PublicProps, Readonly<AutocompleteRootProps> & Readonly<{
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
"onUpdate:open"?: ((value: boolean) => any) | undefined;
onHighlight?: ((payload: {
ref: HTMLElement;
value: string;
} | undefined) => any) | undefined;
}>, {}, {}, {}, {}, string, vue60.ComponentProvideOptions, false, {}, any>, {