reka-ui 0.0.0 → 0.0.2

package/dist/NumberField/NumberFieldRoot.d.ts

@@ -0,0 +1,92 @@
+import { PrimitiveProps } from '../Primitive';
+import { HTMLAttributes, Ref } from 'vue';
+
+export interface NumberFieldRootProps extends PrimitiveProps {
+    defaultValue?: number;
+    modelValue?: number;
+    /** The smallest value allowed for the input. */
+    min?: number;
+    /** The largest value allowed for the input. */
+    max?: number;
+    /** The amount that the input value changes with each increment or decrement "tick". */
+    step?: number;
+    /** Formatting options for the value displayed in the number field. This also affects what characters are allowed to be typed by the user. */
+    formatOptions?: Intl.NumberFormatOptions;
+    /** The locale to use for formatting dates */
+    locale?: string;
+    /** When `true`, prevents the user from interacting with the Number Field. */
+    disabled?: boolean;
+    /** When `true`, indicates that the user must set the value before the owning form can be submitted. */
+    required?: boolean;
+    /** The name of the number field. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    /** Id of the element */
+    id?: string;
+}
+export type NumberFieldRootEmits = {
+    'update:modelValue': [val: number];
+};
+interface NumberFieldRootContext {
+    modelValue: Ref<number>;
+    handleIncrease: (multiplier?: number) => void;
+    handleDecrease: (multiplier?: number) => void;
+    handleMinMaxValue: (type: 'min' | 'max') => void;
+    inputEl: Ref<HTMLInputElement | undefined>;
+    onInputElement: (el: HTMLInputElement) => void;
+    inputMode: Ref<HTMLAttributes['inputmode']>;
+    textValue: Ref<string>;
+    validate: (val: string) => boolean;
+    applyInputValue: (val: string) => void;
+    disabled: Ref<boolean>;
+    max: Ref<number | undefined>;
+    min: Ref<number | undefined>;
+    isDecreaseDisabled: Ref<boolean>;
+    isIncreaseDisabled: Ref<boolean>;
+    id: Ref<string | undefined>;
+}
+export declare const injectNumberFieldRootContext: <T extends NumberFieldRootContext | null | undefined = NumberFieldRootContext>(fallback?: T | undefined) => T extends null ? NumberFieldRootContext | null : NumberFieldRootContext, provideNumberFieldRootContext: (contextValue: NumberFieldRootContext) => NumberFieldRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NumberFieldRootProps>, {
+    as: string;
+    defaultValue: undefined;
+    step: number;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (val: number) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<NumberFieldRootProps>, {
+    as: string;
+    defaultValue: undefined;
+    step: number;
+}>>> & {
+    "onUpdate:modelValue"?: ((val: number) => any) | undefined;
+}, {
+    defaultValue: number;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    step: number;
+}, {}>, {
+    default?(_: {
+        modelValue: number;
+        textValue: string;
+    }): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/NumberField/index.d.ts

@@ -0,0 +1,4 @@
+export { default as NumberFieldRoot, type NumberFieldRootProps, type NumberFieldRootEmits } from './NumberFieldRoot';
+export { default as NumberFieldInput, type NumberFieldInputProps } from './NumberFieldInput';
+export { default as NumberFieldIncrement, type NumberFieldIncrementProps } from './NumberFieldIncrement';
+export { default as NumberFieldDecrement, type NumberFieldDecrementProps } from './NumberFieldDecrement';

package/dist/NumberField/utils.d.ts

@@ -0,0 +1,23 @@
+import { MaybeComputedElementRef } from '@vueuse/core';
+import { Ref } from 'vue';
+
+export declare function usePressedHold(options: {
+    target?: MaybeComputedElementRef;
+    disabled: Ref<boolean>;
+}): {
+    isPressed: Ref<boolean>;
+    onTrigger: import('@vueuse/shared').EventHookOn<any>;
+};
+export declare function useNumberFormatter(locale: Ref<string>, options?: Ref<Intl.NumberFormatOptions | undefined>): {
+    format: (value: number) => string;
+    formatToParts: (value: number) => Intl.NumberFormatPart[];
+    formatRange: (start: number, end: number) => string;
+    formatRangeToParts: (start: number, end: number) => import('@internationalized/number').NumberRangeFormatPart[];
+    resolvedOptions: () => Intl.ResolvedNumberFormatOptions;
+};
+export declare function useNumberParser(locale: Ref<string>, options?: Ref<Intl.NumberFormatOptions | undefined>): {
+    parse: (value: string) => number;
+    isValidPartialNumber: (value: string, minValue?: number | undefined, maxValue?: number | undefined) => boolean;
+    getNumberingSystem: (value: string) => string;
+};
+export declare function handleDecimalOperation(operator: '-' | '+', value1: number, value2: number): number;

package/dist/Pagination/PaginationEllipsis.d.ts

@@ -0,0 +1,22 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface PaginationEllipsisProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<PaginationEllipsisProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<PaginationEllipsisProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Pagination/PaginationFirst.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface PaginationFirstProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationFirstProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationFirstProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Pagination/PaginationLast.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface PaginationLastProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationLastProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationLastProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Pagination/PaginationList.d.ts

@@ -0,0 +1,40 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface PaginationListProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<PaginationListProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<PaginationListProps>>>, {}, {}>, Readonly<{
+    default: (props: {
+        /** Pages item */
+        items: ({
+            type: "ellipsis";
+        } | {
+            type: "page";
+            value: number;
+        })[];
+    }) => any;
+}> & {
+    default: (props: {
+        /** Pages item */
+        items: ({
+            type: "ellipsis";
+        } | {
+            type: "page";
+            value: number;
+        })[];
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Pagination/PaginationListItem.d.ts

@@ -0,0 +1,38 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface PaginationListItemProps extends PrimitiveProps {
+    /** Value for the page */
+    value: number;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationListItemProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationListItemProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Pagination/PaginationNext.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface PaginationNextProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationNextProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationNextProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Pagination/PaginationPrev.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface PaginationPrevProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationPrevProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationPrevProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Pagination/PaginationRoot.d.ts

@@ -0,0 +1,96 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+
+type PaginationRootContext = {
+    page: Ref<number>;
+    onPageChange: (value: number) => void;
+    pageCount: Ref<number>;
+    siblingCount: Ref<number>;
+    disabled: Ref<boolean>;
+    showEdges: Ref<boolean>;
+};
+export interface PaginationRootProps extends PrimitiveProps {
+    /** The controlled value of the current page. Can be binded as `v-model:page`. */
+    page?: number;
+    /**
+     * The value of the page that should be active when initially rendered.
+     *
+     * Use when you do not need to control the value state.
+     */
+    defaultPage?: number;
+    /** Number of items per page */
+    itemsPerPage: number;
+    /** Number of items in your list */
+    total?: number;
+    /** Number of sibling should be shown around the current page */
+    siblingCount?: number;
+    /** When `true`, prevents the user from interacting with item */
+    disabled?: boolean;
+    /** When `true`, always show first page, last page, and ellipsis */
+    showEdges?: boolean;
+}
+export type PaginationRootEmits = {
+    /** Event handler called when the page value changes */
+    'update:page': [value: number];
+};
+export declare const injectPaginationRootContext: <T extends PaginationRootContext | null | undefined = PaginationRootContext>(fallback?: T | undefined) => T extends null ? PaginationRootContext | null : PaginationRootContext, providePaginationRootContext: (contextValue: PaginationRootContext) => PaginationRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationRootProps>, {
+    as: string;
+    total: number;
+    siblingCount: number;
+    defaultPage: number;
+    showEdges: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:page": (value: number) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PaginationRootProps>, {
+    as: string;
+    total: number;
+    siblingCount: number;
+    defaultPage: number;
+    showEdges: boolean;
+}>>> & {
+    "onUpdate:page"?: ((value: number) => any) | undefined;
+}, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+    defaultPage: number;
+    total: number;
+    siblingCount: number;
+    showEdges: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current page state */
+        page: number;
+        /** Number of pages */
+        pageCount: number;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current page state */
+        page: number;
+        /** Number of pages */
+        pageCount: number;
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Pagination/index.d.ts

@@ -0,0 +1,8 @@
+export { default as PaginationRoot, type PaginationRootProps, type PaginationRootEmits } from './PaginationRoot';
+export { default as PaginationEllipsis, type PaginationEllipsisProps } from './PaginationEllipsis';
+export { default as PaginationFirst, type PaginationFirstProps } from './PaginationFirst';
+export { default as PaginationLast, type PaginationLastProps } from './PaginationLast';
+export { default as PaginationList, type PaginationListProps } from './PaginationList';
+export { default as PaginationListItem, type PaginationListItemProps } from './PaginationListItem';
+export { default as PaginationNext, type PaginationNextProps } from './PaginationNext';
+export { default as PaginationPrev, type PaginationPrevProps } from './PaginationPrev';

package/dist/Pagination/utils.d.ts

@@ -0,0 +1,9 @@
+type Pages = Array<{
+    type: 'ellipsis';
+} | {
+    type: 'page';
+    value: number;
+}>;
+export declare function transform(items: (string | number)[]): Pages;
+export declare function getRange(currentPage: number, pageCount: number, siblingCount: number, showEdges: boolean): (string | number)[];
+export {};

package/dist/PinInput/PinInputInput.d.ts

@@ -0,0 +1,33 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface PinInputInputProps extends PrimitiveProps {
+    /** Position of the value this input binds to. */
+    index: number;
+    /** When `true`, prevents the user from interacting with the pin input */
+    disabled?: boolean;
+}
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PinInputInputProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PinInputInputProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/PinInput/PinInputRoot.d.ts

@@ -0,0 +1,94 @@
+import { ComputedRef, Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Direction } from '../shared/types';
+
+export type PinInputRootEmits = {
+    'update:modelValue': [value: string[]];
+    'complete': [value: string[]];
+};
+export interface PinInputRootProps extends PrimitiveProps {
+    /** The controlled checked state of the pin input. Can be binded as `v-model`. */
+    modelValue?: string[];
+    /** The default value of the pin inputs when it is initially rendered. Use when you do not need to control its checked state. */
+    defaultValue?: string[];
+    /** The placeholder character to use for empty pin-inputs. */
+    placeholder?: string;
+    /** When `true`, pin inputs will be treated as password. */
+    mask?: boolean;
+    /** When `true`, mobile devices will autodetect the OTP from messages or clipboard, and enable the autocomplete field. */
+    otp?: boolean;
+    /** Input type for the inputs. */
+    type?: 'text' | 'number';
+    /** The reading direction of the combobox when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+    /** The name of the pin input. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    /** When `true`, prevents the user from interacting with the pin input */
+    disabled?: boolean;
+    /** When `true`, indicates that the user must check the pin input before the owning form can be submitted. */
+    required?: boolean;
+    /** Id of the element */
+    id?: string;
+}
+export interface PinInputRootContext {
+    modelValue: Ref<string[]>;
+    mask: Ref<boolean>;
+    otp: Ref<boolean>;
+    placeholder: Ref<string>;
+    type: Ref<PinInputRootProps['type']>;
+    dir: Ref<Direction>;
+    disabled: Ref<boolean>;
+    isCompleted: ComputedRef<boolean>;
+    inputElements?: Ref<Set<HTMLInputElement>>;
+    onInputElementChange: (el: HTMLInputElement) => void;
+}
+export declare const injectPinInputRootContext: <T extends PinInputRootContext | null | undefined = PinInputRootContext>(fallback?: T | undefined) => T extends null ? PinInputRootContext | null : PinInputRootContext, providePinInputRootContext: (contextValue: PinInputRootContext) => PinInputRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PinInputRootProps>, {
+    placeholder: string;
+    type: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string[]) => void;
+    complete: (value: string[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<PinInputRootProps>, {
+    placeholder: string;
+    type: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((value: string[]) => any) | undefined;
+    onComplete?: ((value: string[]) => any) | undefined;
+}, {
+    type: "number" | "text";
+    placeholder: string;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current input values */
+        modelValue: string[];
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current input values */
+        modelValue: string[];
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/PinInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default as PinInputRoot, type PinInputRootProps, type PinInputRootEmits } from './PinInputRoot';
+export { default as PinInputInput, type PinInputInputProps } from './PinInputInput';

package/dist/Popover/PopoverAnchor.d.ts

@@ -0,0 +1,22 @@
+import { PopperAnchorProps } from '../Popper';
+
+export interface PopoverAnchorProps extends PopperAnchorProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<PopoverAnchorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<PopoverAnchorProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};