reka-ui
Version:
Vue port for Radix UI Primitives.
1,133 lines (1,129 loc) • 405 kB
TypeScript
import { DateRange, DateStep, DateValue, Grid, HourCycle, Matcher, SegmentPart, SegmentValueObj, WeekDayFormat } from "./index2.js";
import * as vue32 from "vue";
import { CSSProperties, Component, ComponentPublicInstance, ComputedRef, DefineComponent, HTMLAttributes, ImgHTMLAttributes, MaybeRef, MaybeRefOrGetter, PropType, Ref, SlotsType, UnwrapNestedRefs, VNode, VNodeProps, VNodeRef } from "vue";
import { EventHook, EventHookOn } from "@vueuse/core";
import * as _internationalized_date623 from "@internationalized/date";
import { CalendarDateTime, DateValue as DateValue$1, Time, ZonedDateTime } from "@internationalized/date";
import { ReferenceElement, ReferenceElement as ReferenceElement$1 } from "@floating-ui/vue";
import { VirtualItem, Virtualizer } from "@tanstack/vue-virtual";
import { ComponentProps } from "vue-component-type-helpers";
//#region src/shared/createContext.d.ts
/**
* @param providerComponentName - The name(s) of the component(s) providing the context.
*
* There are situations where context can come from multiple components. In such cases, you might need to give an array of component names to provide your context, instead of just a single string.
*
* @param contextName The description for injection key symbol.
*/
declare function createContext<ContextValue>(providerComponentName: string | string[], contextName?: string): readonly [<T extends ContextValue | null | undefined = ContextValue>(fallback?: T) => T extends null ? ContextValue | null : ContextValue, (contextValue: ContextValue) => ContextValue];
//# sourceMappingURL=createContext.d.ts.map
//#endregion
//#region src/shared/date/comparators.d.ts
type TimeValue = Time | CalendarDateTime | ZonedDateTime;
type Granularity = 'day' | 'hour' | 'minute' | 'second';
//#endregion
//#region src/shared/types.d.ts
type DataOrientation = 'vertical' | 'horizontal';
type Direction = 'ltr' | 'rtl';
type SingleOrMultipleType = 'single' | 'multiple';
interface SingleOrMultipleProps<T = AcceptableValue | AcceptableValue[]> {
/**
* Determines whether a "single" or "multiple" items can be selected at a time.
*
* This prop will overwrite the inferred type from `modelValue` and `defaultValue`.
*/
type?: SingleOrMultipleType;
/**
* The controlled value of the active item(s).
*
* Use this when you need to control the state of the items. Can be binded with `v-model`
*/
modelValue?: T;
/**
* The default active value of the item(s).
*
* Use when you do not need to control the state of the item(s).
*/
defaultValue?: T;
}
/**
* if padding or margin is number, it will be in px
* if padding or margin is true, it will be var(--scrollbar-width)
* otherwise, it will be passed string
*/
type ScrollBodyOption = {
padding?: boolean | number | string;
margin?: boolean | number | string;
};
type AcceptableValue = string | number | bigint | Record<string, any> | null;
type StringOrNumber = string | number;
type GenericComponentInstance<T> = T extends (new (...args: any[]) => infer R) ? R : T extends ((...args: any[]) => infer R) ? R extends {
__ctx?: infer K;
} ? Exclude<K, void> extends {
expose: (...args: infer Y) => void;
} ? Y[0] & InstanceType<DefineComponent> : any : any : any;
interface FormFieldProps {
/** 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;
}
//#endregion
//#region src/shared/useBodyScrollLock.d.ts
declare function useBodyScrollLock(initialState?: boolean | undefined): vue32.WritableComputedRef<boolean, boolean>;
//# sourceMappingURL=useBodyScrollLock.d.ts.map
//#endregion
//#region src/shared/useDateFormatter.d.ts
interface DateFormatterOptions extends Intl.DateTimeFormatOptions {
calendar?: string;
}
type Formatter = {
getLocale: () => string;
setLocale: (newLocale: string) => void;
custom: (date: Date, options: DateFormatterOptions) => string;
selectedDate: (date: DateValue$1, includeTime?: boolean) => string;
dayOfWeek: (date: Date, length?: DateFormatterOptions['weekday']) => string;
fullMonthAndYear: (date: Date, options?: DateFormatterOptions) => string;
fullMonth: (date: Date, options?: DateFormatterOptions) => string;
fullYear: (date: Date, options?: DateFormatterOptions) => string;
dayPeriod: (date: Date) => string;
part: (dateObj: DateValue$1, type: Intl.DateTimeFormatPartTypes, options?: DateFormatterOptions) => string;
toParts: (date: DateValue$1, options?: DateFormatterOptions) => Intl.DateTimeFormatPart[];
getMonths: () => {
label: string;
value: number;
}[];
};
/**
* Creates a wrapper around the `DateFormatter`, which is
* an improved version of the {@link Intl.DateTimeFormat} API,
* that is used internally by the various date builders to
* easily format dates in a consistent way.
*
* @see [DateFormatter](https://react-spectrum.adobe.com/internationalized/date/DateFormatter.html)
*/
declare function useDateFormatter(initialLocale: string, opts?: DateFormatterOptions): Formatter;
//# sourceMappingURL=useDateFormatter.d.ts.map
//#endregion
//#region src/shared/useDirection.d.ts
/**
* The `useDirection` function provides a way to access the current direction in your application.
* @param {Ref<Direction | undefined>} [dir] - An optional ref containing the direction (ltr or rtl).
* @returns computed value that combines with the resolved direction.
*/
declare function useDirection(dir?: Ref<Direction | undefined>): vue32.ComputedRef<Direction>;
//# sourceMappingURL=useDirection.d.ts.map
//#endregion
//#region src/shared/useEmitAsProps.d.ts
/**
* The `useEmitAsProps` function is a TypeScript utility that converts emitted events into props for a
* Vue component.
* @param emit - The `emit` parameter is a function that is used to emit events from a component. It
* takes two parameters: `name` which is the name of the event to be emitted, and `...args` which are
* the arguments to be passed along with the event.
* @returns The function `useEmitAsProps` returns an object that maps event names to functions that
* call the `emit` function with the corresponding event name and arguments.
*/
declare function useEmitAsProps<Name extends string>(emit: (name: Name, ...args: any[]) => void): Record<string, any>;
//# sourceMappingURL=useEmitAsProps.d.ts.map
//#endregion
//#region src/shared/useFilter.d.ts
/**
* Provides locale-aware string filtering functions.
* Uses `Intl.Collator` for comparison to ensure proper Unicode handling.
*
* @param options - Optional collator options to customize comparison behavior.
* See [Intl.CollatorOptions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator#options) for details.
* @returns An object with methods to check if a string starts with, ends with, or contains a substring.
*
* @example
* const { startsWith, endsWith, contains } = useFilter();
*
* startsWith('hello', 'he'); // true
* endsWith('hello', 'lo'); // true
* contains('hello', 'ell'); // true
*/
declare function useFilter(options?: MaybeRef<Intl.CollatorOptions>): {
startsWith: (string: string, substring: string) => boolean;
endsWith: (string: string, substring: string) => boolean;
contains: (string: string, substring: string) => boolean;
};
//# sourceMappingURL=useFilter.d.ts.map
//#endregion
//#region src/shared/useForwardExpose.d.ts
declare function useForwardExpose<T extends ComponentPublicInstance>(): {
forwardRef: (ref: Element | T | null) => void;
currentRef: vue32.Ref<Element | T | null | undefined, Element | T | null | undefined>;
currentElement: vue32.ComputedRef<HTMLElement>;
};
//# sourceMappingURL=useForwardExpose.d.ts.map
//#endregion
//#region src/shared/useForwardProps.d.ts
/**
* The `useForwardProps` function in TypeScript takes in a set of props and returns a computed value
* that combines default props with assigned props from the current instance.
* @param {T} props - The `props` parameter is an object that represents the props passed to a
* component.
* @returns computed value that combines the default props, preserved props, and assigned props.
*/
declare function useForwardProps<T extends Record<string, any>>(props: MaybeRefOrGetter<T>): vue32.ComputedRef<T>;
//# sourceMappingURL=useForwardProps.d.ts.map
//#endregion
//#region src/shared/useForwardPropsEmits.d.ts
/**
* The function `useForwardPropsEmits` takes in props and an optional emit function, and returns a
* computed object that combines the parsed props and emits as props.
* @param {T} props - The `props` parameter is of type `T`, which is a generic type that extends the
* parameters of the `useForwardProps` function. It represents the props object that is passed to the
* `useForwardProps` function.
* @param [emit] - The `emit` parameter is a function that can be used to emit events. It takes two
* arguments: `name`, which is the name of the event to be emitted, and `args`, which are the arguments
* to be passed along with the event.
* @returns a computed property that combines the parsed
* props and emits as props.
*/
declare function useForwardPropsEmits<T extends Record<string, any>, Name extends string>(props: MaybeRefOrGetter<T>, emit?: (name: Name, ...args: any[]) => void): vue32.ComputedRef<T & Record<string, any>>;
//# sourceMappingURL=useForwardPropsEmits.d.ts.map
//#endregion
//#region src/shared/useId.d.ts
/**
* The `useId` function generates a unique identifier using a provided deterministic ID or a default
* one prefixed with "reka-", or the provided one via `useId` props from `<ConfigProvider>`.
* @param {string | null | undefined} [deterministicId] - The `useId` function you provided takes an
* optional parameter `deterministicId`, which can be a string, null, or undefined. If
* `deterministicId` is provided, the function will return it. Otherwise, it will generate an id using
* the `useId` function obtained
*/
declare function useId(deterministicId?: string | null | undefined, prefix?: string): string;
//# sourceMappingURL=useId.d.ts.map
//#endregion
//#region src/shared/useLocale.d.ts
/**
* The `useLocale` function provides a way to access the current locale in your application.
* @param {Ref<string | undefined>} [locale] - An optional ref containing the locale.
* @returns A computed ref holding the resolved locale.
*/
declare function useLocale(locale?: Ref<string | undefined>): vue32.ComputedRef<string>;
//# sourceMappingURL=useLocale.d.ts.map
//#endregion
//#region src/shared/useSelectionBehavior.d.ts
declare function useSelectionBehavior<T>(modelValue: Ref<T | T[]>, props: UnwrapNestedRefs<{
multiple?: boolean;
selectionBehavior?: 'toggle' | 'replace';
}>): {
firstValue: Ref<any, any>;
onSelectItem: (val: T, condition: (existingValue: T) => boolean) => T | T[];
handleMultipleReplace: (intent: "first" | "last" | "prev" | "next", currentElement: HTMLElement | Element | null, getItems: () => {
ref: HTMLElement;
value?: any;
}[], options: any[]) => void;
};
//# sourceMappingURL=useSelectionBehavior.d.ts.map
//#endregion
//#region src/shared/useStateMachine.d.ts
interface Machine<S> {
[k: string]: {
[k: string]: S;
};
}
type MachineState<T> = keyof T;
type MachineEvent<T> = keyof UnionToIntersection<T[keyof T]>;
type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends ((x: infer R) => any) ? R : never;
/**
* The `useStateMachine` function is a TypeScript function that creates a state machine and returns the
* current state and a dispatch function to update the state based on events.
* @param initialState - The `initialState` parameter is the initial state of the state machine. It
* represents the starting point of the state machine's state.
* @param machine - The `machine` parameter is an object that represents a state machine. It should
* have keys that correspond to the possible states of the machine, and the values should be objects
* that represent the possible events and their corresponding next states.
* @returns The `useStateMachine` function returns an object with two properties: `state` and
* `dispatch`.
*/
declare function useStateMachine<M>(initialState: MachineState<M>, machine: M & Machine<MachineState<M>>): {
state: Ref<keyof M, keyof M>;
dispatch: (event: MachineEvent<M>) => void;
};
//#endregion
//#region src/shared/withDefault.d.ts
type RawProps = VNodeProps & {
__v_isVNode?: never;
[Symbol.iterator]?: never;
} & Record<string, any>;
interface MountingOptions<Props> {
/**
* Default props for the component
*/
props?: (RawProps & Props) | ({} extends Props ? null : never) | ((attrs: Record<string, any>) => (RawProps & Props));
/**
* Pass attributes into the component
*/
attrs?: Record<string, unknown>;
}
declare function withDefault<T, C = (T extends ((...args: any) => any) | (new (...args: any) => any) ? T : T extends {
props?: infer Props;
} ? DefineComponent<Props extends Readonly<(infer PropNames)[]> | (infer PropNames)[] ? { [key in PropNames extends string ? PropNames : string]?: any } : Props> : DefineComponent), P extends ComponentProps<C> = ComponentProps<C>>(originalComponent: T, options?: MountingOptions<P>): T;
//#endregion
//#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: vue32.DefineComponent<vue32.ExtractPropTypes<{
asChild: {
type: BooleanConstructor;
default: boolean;
};
as: {
type: PropType<AsTag | Component>;
default: string;
};
}>, () => vue32.VNode<vue32.RendererNode, vue32.RendererElement, {
[key: string]: any;
}>, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<vue32.ExtractPropTypes<{
asChild: {
type: BooleanConstructor;
default: boolean;
};
as: {
type: PropType<AsTag | Component>;
default: string;
};
}>> & Readonly<{}>, {
asChild: boolean;
as: AsTag | Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, true, {}, any>;
//# sourceMappingURL=Primitive.d.ts.map
//#endregion
//#region src/Primitive/Slot.d.ts
declare const Slot: vue32.DefineComponent<{}, () => vue32.VNode<vue32.RendererNode, vue32.RendererElement, {
[key: string]: any;
}> | vue32.VNode<vue32.RendererNode, vue32.RendererElement, {
[key: string]: any;
}>[] | null, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue32.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$33: __VLS_WithSlots$288<vue32.DefineComponent<CollapsibleContentProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {
contentFound: (args_0: void) => any;
}, string, vue32.PublicProps, Readonly<CollapsibleContentProps> & Readonly<{
onContentFound?: ((args_0?: void | undefined) => any) | undefined;
}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$288<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$34: __VLS_WithSlots$287<vue32.DefineComponent<CollapsibleRootProps, {
open: Ref<boolean, boolean>;
}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, vue32.PublicProps, Readonly<CollapsibleRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {
defaultOpen: boolean;
open: boolean;
unmountOnHide: boolean;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current open state */
open: boolean;
}) => any;
}>;
type __VLS_WithSlots$287<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$35: __VLS_WithSlots$286<vue32.DefineComponent<CollapsibleTriggerProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<CollapsibleTriggerProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$286<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: __VLS_WithSlots$285<vue32.DefineComponent<AccordionContentProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AccordionContentProps> & Readonly<{}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$285<T, S> = T & {
new (): {
$slots: S;
};
};
//#endregion
//#region src/Accordion/AccordionHeader.vue.d.ts
interface AccordionHeaderProps extends PrimitiveProps {}
declare const _default$1: __VLS_WithSlots$284<vue32.DefineComponent<AccordionHeaderProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AccordionHeaderProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$284<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$2: __VLS_WithSlots$283<vue32.DefineComponent<AccordionItemProps, {
open: ComputedRef<boolean>;
dataDisabled: ComputedRef<"" | undefined>;
}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AccordionItemProps> & Readonly<{}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current open state */
open: boolean;
}) => any;
}>;
type __VLS_WithSlots$283<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$3: <T extends (string | string[]), ExplicitType extends SingleOrMultipleType>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$14<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
props: __VLS_PrettifyLocal$14<Pick<Partial<{}> & Omit<{
readonly "onUpdate:modelValue"?: ((value: (ExplicitType extends "single" ? string : string[]) | undefined) => any) | undefined;
} & vue32.VNodeProps & vue32.AllowedComponentProps & vue32.ComponentCustomProps, never>, "onUpdate:modelValue"> & AccordionRootProps<T> & Partial<{}>> & vue32.PublicProps;
expose(exposed: vue32.ShallowUnwrapRef<{}>): 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;
}>) => vue32.VNode & {
__ctx?: Awaited<typeof __VLS_setup>;
};
type __VLS_PrettifyLocal$14<T> = { [K in keyof T]: T[K] } & {};
//# sourceMappingURL=AccordionRoot.vue.d.ts.map
//#endregion
//#region src/Accordion/AccordionTrigger.vue.d.ts
interface AccordionTriggerProps extends PrimitiveProps {}
declare const _default$4: __VLS_WithSlots$282<vue32.DefineComponent<AccordionTriggerProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AccordionTriggerProps> & Readonly<{}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$282<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$113: __VLS_WithSlots$281<vue32.DefineComponent<DialogCloseProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<DialogCloseProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$281<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$114: __VLS_WithSlots$280<vue32.DefineComponent<DialogContentProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {
openAutoFocus: (event: Event) => any;
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
closeAutoFocus: (event: Event) => any;
}, string, vue32.PublicProps, Readonly<DialogContentProps> & Readonly<{
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
} & {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$280<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$115: __VLS_WithSlots$279<vue32.DefineComponent<DialogDescriptionProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<DialogDescriptionProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$279<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$116: __VLS_WithSlots$278<vue32.DefineComponent<DialogOverlayProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<DialogOverlayProps> & Readonly<{}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$278<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$117: __VLS_WithSlots$277<vue32.DefineComponent<DialogPortalProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<DialogPortalProps> & Readonly<{}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$277<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$118: __VLS_WithSlots$276<vue32.DefineComponent<DialogRootProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, vue32.PublicProps, Readonly<DialogRootProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {
defaultOpen: boolean;
open: boolean;
modal: boolean;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current open state */
open: boolean;
/** Close the dialog */
close: () => void;
}) => any;
}>;
type __VLS_WithSlots$276<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$119: __VLS_WithSlots$275<vue32.DefineComponent<DialogTitleProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<DialogTitleProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$275<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$120: __VLS_WithSlots$274<vue32.DefineComponent<DialogTriggerProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<DialogTriggerProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$274<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$5: __VLS_WithSlots$273<vue32.DefineComponent<AlertDialogActionProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AlertDialogActionProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$273<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$6: __VLS_WithSlots$272<vue32.DefineComponent<AlertDialogCancelProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AlertDialogCancelProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$272<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$7: __VLS_WithSlots$271<vue32.DefineComponent<AlertDialogContentProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {
openAutoFocus: (event: Event) => any;
escapeKeyDown: (event: KeyboardEvent) => any;
pointerDownOutside: (event: PointerDownOutsideEvent) => any;
focusOutside: (event: FocusOutsideEvent) => any;
interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
closeAutoFocus: (event: Event) => any;
}, string, vue32.PublicProps, Readonly<AlertDialogContentProps> & Readonly<{
onOpenAutoFocus?: ((event: Event) => any) | undefined;
onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
onCloseAutoFocus?: ((event: Event) => any) | undefined;
}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$271<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$8: __VLS_WithSlots$270<vue32.DefineComponent<AlertDialogDescriptionProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AlertDialogDescriptionProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$270<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$9: __VLS_WithSlots$269<vue32.DefineComponent<AlertDialogOverlayProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AlertDialogOverlayProps> & Readonly<{}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$269<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$10: __VLS_WithSlots$268<vue32.DefineComponent<AlertDialogPortalProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AlertDialogPortalProps> & Readonly<{}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$268<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$11: __VLS_WithSlots$267<vue32.DefineComponent<AlertDialogProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {
"update:open": (value: boolean) => any;
}, string, vue32.PublicProps, Readonly<AlertDialogProps> & Readonly<{
"onUpdate:open"?: ((value: boolean) => any) | undefined;
}>, {}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
open: boolean;
close: () => void;
}) => any;
}>;
type __VLS_WithSlots$267<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$12: __VLS_WithSlots$266<vue32.DefineComponent<AlertDialogTitleProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AlertDialogTitleProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$266<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$13: __VLS_WithSlots$265<vue32.DefineComponent<AlertDialogTriggerProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AlertDialogTriggerProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$265<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$14: __VLS_WithSlots$264<vue32.DefineComponent<AspectRatioProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AspectRatioProps> & Readonly<{}>, {
ratio: number;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {
/** Current aspect ratio (in %) */
aspect: number;
}) => any;
}>;
type __VLS_WithSlots$264<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AspectRatio.vue.d.ts.map
//#endregion
//#region src/Avatar/AvatarFallback.vue.d.ts
interface AvatarFallbackProps extends PrimitiveProps {
/** Useful for delaying rendering so it only appears for those with slower connections. */
delayMs?: number;
}
declare const _default$15: __VLS_WithSlots$263<vue32.DefineComponent<AvatarFallbackProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AvatarFallbackProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$263<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AvatarFallback.vue.d.ts.map
//#endregion
//#region src/Avatar/utils.d.ts
type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';
//#endregion
//#region src/Avatar/AvatarImage.vue.d.ts
type AvatarImageEmits = {
/**
* A callback providing information about the loading status of the image. <br>
* This is useful in case you want to control more precisely what to render as the image is loading.
*/
loadingStatusChange: [value: ImageLoadingStatus];
};
interface AvatarImageProps extends PrimitiveProps {
src: string;
referrerPolicy?: ImgHTMLAttributes['referrerpolicy'];
crossOrigin?: ImgHTMLAttributes['crossorigin'];
}
declare const _default$16: __VLS_WithSlots$262<vue32.DefineComponent<AvatarImageProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {
loadingStatusChange: (value: ImageLoadingStatus) => any;
}, string, vue32.PublicProps, Readonly<AvatarImageProps> & Readonly<{
onLoadingStatusChange?: ((value: ImageLoadingStatus) => any) | undefined;
}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$262<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AvatarImage.vue.d.ts.map
//#endregion
//#region src/Avatar/AvatarRoot.vue.d.ts
interface AvatarRootProps extends PrimitiveProps {}
type AvatarRootContext = {
imageLoadingStatus: Ref<ImageLoadingStatus>;
};
declare const injectAvatarRootContext: <T extends AvatarRootContext | null | undefined = AvatarRootContext>(fallback?: T | undefined) => T extends null ? AvatarRootContext | null : AvatarRootContext, provideAvatarRootContext: (contextValue: AvatarRootContext) => AvatarRootContext;
declare const _default$17: __VLS_WithSlots$261<vue32.DefineComponent<AvatarRootProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<AvatarRootProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$261<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=AvatarRoot.vue.d.ts.map
//#endregion
//#region src/Calendar/CalendarCell.vue.d.ts
interface CalendarCellProps extends PrimitiveProps {
/** The date value for the cell */
date: DateValue$1;
}
declare const _default$18: __VLS_WithSlots$260<vue32.DefineComponent<CalendarCellProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<CalendarCellProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$260<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=CalendarCell.vue.d.ts.map
//#endregion
//#region src/Calendar/CalendarCellTrigger.vue.d.ts
interface CalendarCellTriggerProps extends PrimitiveProps {
/** The date value provided to the cell trigger */
day: DateValue$1;
/** The month in which the cell is rendered */
month: DateValue$1;
}
interface CalendarCellTriggerSlot {
default?: (props: {
/** Current day */
dayValue: string;
/** Current disable state */
disabled: boolean;
/** Current selected state */
selected: boolean;
/** Current today state */
today: boolean;
/** Current outside view state */
outsideView: boolean;
/** Current outside visible view state */
outsideVisibleView: boolean;
/** Current unavailable state */
unavailable: boolean;
}) => any;
}
declare const _default$19: __VLS_WithSlots$259<vue32.DefineComponent<CalendarCellTriggerProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<CalendarCellTriggerProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, CalendarCellTriggerSlot>;
type __VLS_WithSlots$259<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=CalendarCellTrigger.vue.d.ts.map
//#endregion
//#region src/Calendar/CalendarGrid.vue.d.ts
interface CalendarGridProps extends PrimitiveProps {}
declare const _default$20: __VLS_WithSlots$258<vue32.DefineComponent<CalendarGridProps, {}, {}, {}, {}, vue32.ComponentOptionsMixin, vue32.ComponentOptionsMixin, {}, string, vue32.PublicProps, Readonly<CalendarGridProps> & Readonly<{}>, {
as: AsTag | vue32.Component;
}, {}, {}, {}, string, vue32.ComponentProvideOptions, false, {}, any>, {
default?: (props: {}) => any;
}>;
type __VLS_WithSlots$258<T, S> = T & {
new (): {
$slots: S;
};
};
//# sourceMappingURL=CalendarGrid.vue.d.ts.map
//#endregion
//#region src/Calendar/CalendarGridBody.vue.d.ts
interface CalendarGridBodyProps extends PrimitiveProps {}
declare const _default$21: __VLS_WithSlots$257<vue32.DefineComponent<CalendarGridBodyProps, {}, {}, {}, {}