reka-ui 0.0.0 → 0.0.2

package/dist/Splitter/utils/debounce.d.ts

@@ -0,0 +1 @@
+export default function debounce<T extends Function>(callback: T, durationMs?: number): T;

package/dist/Splitter/utils/dom.d.ts

@@ -0,0 +1,9 @@
+import { PanelData } from '../SplitterPanel';
+
+export declare function getPanelElement(id: string, scope?: ParentNode | HTMLElement): HTMLElement | null;
+export declare function getPanelElementsForGroup(groupId: string, scope?: ParentNode | HTMLElement): HTMLElement[];
+export declare function getPanelGroupElement(id: string, rootElement?: ParentNode | HTMLElement): HTMLElement | null;
+export declare function getResizeHandleElement(id: string, scope?: ParentNode | HTMLElement): HTMLElement | null;
+export declare function getResizeHandleElementIndex(groupId: string, id: string, scope?: ParentNode | HTMLElement): number | null;
+export declare function getResizeHandleElementsForGroup(groupId: string, scope?: ParentNode | HTMLElement): HTMLElement[];
+export declare function getResizeHandlePanelIds(groupId: string, handleId: string, panelsArray: PanelData[], scope?: ParentNode | HTMLElement): [idBefore: string | null, idAfter: string | null];

package/dist/Splitter/utils/events.d.ts

@@ -0,0 +1,10 @@
+import { Direction, ResizeEvent } from './types';
+
+export declare function isKeyDown(event: ResizeEvent): event is KeyboardEvent;
+export declare function isMouseEvent(event: ResizeEvent): event is MouseEvent;
+export declare function isTouchEvent(event: ResizeEvent): event is TouchEvent;
+export declare function getResizeEventCoordinates(event: ResizeEvent): {
+    x: number;
+    y: number;
+};
+export declare function getResizeEventCursorPosition(direction: Direction, event: ResizeEvent): number;

package/dist/Splitter/utils/layout.d.ts

@@ -0,0 +1,10 @@
+import { PanelConstraints } from '../SplitterPanel';
+
+export declare function compareLayouts(a: number[], b: number[]): boolean;
+export declare function adjustLayoutByDelta({ delta, layout: prevLayout, panelConstraints: panelConstraintsArray, pivotIndices, trigger, }: {
+    delta: number;
+    layout: number[];
+    panelConstraints: PanelConstraints[];
+    pivotIndices: number[];
+    trigger: 'imperative-api' | 'keyboard' | 'mouse-or-touch';
+}): number[];

package/dist/Splitter/utils/pivot.d.ts

@@ -0,0 +1 @@
+export declare function determinePivotIndices(groupId: string, dragHandleId: string, panelGroupElement: ParentNode): [indexBefore: number, indexAfter: number];

package/dist/Splitter/utils/rects.d.ts

@@ -0,0 +1,8 @@
+export interface Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function intersects(rectOne: Rectangle, rectTwo: Rectangle, strict: boolean): boolean;
+export declare function getIntersectingRectangle(rectOne: Rectangle, rectTwo: Rectangle, strict: boolean): Rectangle;

package/dist/Splitter/utils/registry.d.ts

@@ -0,0 +1,20 @@
+import { Direction, ResizeEvent } from './types';
+
+export type ResizeHandlerAction = 'down' | 'move' | 'up';
+export type SetResizeHandlerState = (action: ResizeHandlerAction, isActive: boolean, event: ResizeEvent) => void;
+export type PointerHitAreaMargins = {
+    coarse: number;
+    fine: number;
+};
+export type ResizeHandlerData = {
+    direction: Direction;
+    element: HTMLElement;
+    hitAreaMargins: PointerHitAreaMargins;
+    setResizeHandlerState: SetResizeHandlerState;
+};
+export declare const EXCEEDED_HORIZONTAL_MIN = 1;
+export declare const EXCEEDED_HORIZONTAL_MAX = 2;
+export declare const EXCEEDED_VERTICAL_MIN = 4;
+export declare const EXCEEDED_VERTICAL_MAX = 8;
+export declare function registerResizeHandle(resizeHandleId: string, element: HTMLElement, direction: Direction, hitAreaMargins: PointerHitAreaMargins, setResizeHandlerState: SetResizeHandlerState): () => void;
+export declare function reportConstraintsViolation(resizeHandleId: string, flag: number): void;

package/dist/Splitter/utils/resizePanel.d.ts

@@ -0,0 +1,7 @@
+import { PanelConstraints } from '../SplitterPanel';
+
+export declare function resizePanel({ panelConstraints: panelConstraintsArray, panelIndex, size, }: {
+    panelConstraints: PanelConstraints[];
+    panelIndex: number;
+    size: number;
+}): number;

package/dist/Splitter/utils/stackingOrder.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determine which of two nodes appears in front of the other —
+ * if `a` is in front, returns 1, otherwise returns -1
+ * @param {HTMLElement} a
+ * @param {HTMLElement} b
+ */
+export declare function compare(a: HTMLElement, b: HTMLElement): number;

package/dist/Splitter/utils/storage.d.ts

@@ -0,0 +1,15 @@
+import { PanelGroupStorage } from '../SplitterGroup';
+import { PanelData } from '../SplitterPanel';
+
+export declare function initializeDefaultStorage(storageObject: PanelGroupStorage): void;
+export type PanelConfigurationState = {
+    expandToSizes: {
+        [panelId: string]: number;
+    };
+    layout: number[];
+};
+export type SerializedPanelGroupState = {
+    [panelIds: string]: PanelConfigurationState;
+};
+export declare function loadPanelGroupState(autoSaveId: string, panels: PanelData[], storage: PanelGroupStorage): PanelConfigurationState | null;
+export declare function savePanelGroupState(autoSaveId: string, panels: PanelData[], panelSizesBeforeCollapse: Map<string, number>, sizes: number[], storage: PanelGroupStorage): void;

package/dist/Splitter/utils/style.d.ts

@@ -0,0 +1,17 @@
+import { PanelData } from '../SplitterPanel';
+import { DragState } from './types';
+import { CSSProperties } from 'vue';
+
+type CursorState = 'horizontal' | 'intersection' | 'vertical';
+export declare function getCursorStyle(state: CursorState, constraintFlags: number): string;
+export declare function resetGlobalCursorStyle(): void;
+export declare function setGlobalCursorStyle(state: CursorState, constraintFlags: number): void;
+export declare function computePanelFlexBoxStyle({ defaultSize, dragState, layout, panelData, panelIndex, precision, }: {
+    defaultSize: number | undefined;
+    layout: number[];
+    dragState: DragState | null;
+    panelData: PanelData[];
+    panelIndex: number;
+    precision?: number;
+}): CSSProperties;
+export {};

package/dist/Splitter/utils/types.d.ts

@@ -0,0 +1,9 @@
+export type Direction = 'horizontal' | 'vertical';
+export type ResizeEvent = KeyboardEvent | MouseEvent | TouchEvent;
+export type ResizeHandler = (event: ResizeEvent) => void;
+export type DragState = {
+    dragHandleId: string;
+    dragHandleRect: DOMRect;
+    initialCursorPosition: number;
+    initialLayout: number[];
+};

package/dist/Splitter/utils/validation.d.ts

@@ -0,0 +1,11 @@
+import { PanelConstraints } from '../SplitterPanel';
+
+export declare function validatePanelGroupLayout({ layout: prevLayout, panelConstraints, }: {
+    layout: number[];
+    panelConstraints: PanelConstraints[];
+}): number[];
+export declare function validatePanelConstraints({ panelConstraints: panelConstraintsArray, panelId, panelIndex, }: {
+    panelConstraints: PanelConstraints[];
+    panelId: string | undefined;
+    panelIndex: number;
+}): boolean;

package/dist/Stepper/StepperDescription.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface StepperDescriptionProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperDescriptionProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperDescriptionProps>, {
+    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/Stepper/StepperIndicator.d.ts

@@ -0,0 +1,21 @@
+import { PrimitiveProps } from '../Primitive';
+export interface StepperIndicatorProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<StepperIndicatorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<StepperIndicatorProps>>>, {}, {}>, {
+    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/Stepper/StepperItem.d.ts

@@ -0,0 +1,64 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+
+export declare const injectStepperItemContext: <T extends StepperItemContext | null | undefined = StepperItemContext>(fallback?: T | undefined) => T extends null ? StepperItemContext | null : StepperItemContext, provideStepperItemContext: (contextValue: StepperItemContext) => StepperItemContext;
+export type StepperState = 'completed' | 'active' | 'inactive';
+export interface StepperItemContext {
+    titleId: string;
+    descriptionId: string;
+    step: Ref<number>;
+    state: Ref<StepperState>;
+    disabled: Ref<boolean>;
+    isFocusable: Ref<boolean>;
+}
+export interface StepperItemProps extends PrimitiveProps {
+    /** A unique value that associates the stepper item with an index */
+    step: number;
+    /** When `true`, prevents the user from interacting with the tab. */
+    disabled?: boolean;
+    /** Shows whether the step is completed. */
+    completed?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperItemProps>, {
+    completed: boolean;
+    disabled: boolean;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperItemProps>, {
+    completed: boolean;
+    disabled: boolean;
+}>>>, {
+    disabled: boolean;
+    completed: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** The current state of the stepper item */
+        state: StepperState;
+    }) => any;
+}> & {
+    default: (props: {
+        /** The current state of the stepper item */
+        state: StepperState;
+    }) => 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/Stepper/StepperRoot.d.ts

@@ -0,0 +1,88 @@
+import { Ref } from 'vue';
+import { DataOrientation, Direction } from '../shared/types';
+import { PrimitiveProps } from '../Primitive';
+
+export interface StepperRootContext {
+    modelValue: Ref<number | undefined>;
+    changeModelValue: (value: number) => void;
+    orientation: Ref<DataOrientation>;
+    dir: Ref<Direction>;
+    linear: Ref<boolean>;
+    stepperItems: Ref<Set<HTMLElement>>;
+    totalStepperItems: Ref<Set<HTMLElement>>;
+}
+export interface StepperRootProps extends PrimitiveProps {
+    /**
+     * The value of the tab that should be active when initially rendered. Use when you do not need to control the state of the tabs
+     */
+    defaultValue?: number;
+    /**
+     * The orientation the tabs are laid out.
+     * Mainly so arrow navigation is done accordingly (left & right vs. up & down)
+     * @defaultValue horizontal
+     */
+    orientation?: DataOrientation;
+    /**
+     * 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 controlled value of the tab to activate. Can be bound as `v-model`. */
+    modelValue?: number;
+    /** Whether or not the steps must be completed in order */
+    linear?: boolean;
+}
+export type StepperRootEmits = {
+    /** Event handler called when the value changes */
+    'update:modelValue': [payload: number | undefined];
+};
+export declare const injectStepperRootContext: <T extends StepperRootContext | null | undefined = StepperRootContext>(fallback?: T | undefined) => T extends null ? StepperRootContext | null : StepperRootContext, provideStepperRootContext: (contextValue: StepperRootContext) => StepperRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperRootProps>, {
+    orientation: string;
+    linear: boolean;
+    defaultValue: number;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (payload: number | undefined) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperRootProps>, {
+    orientation: string;
+    linear: boolean;
+    defaultValue: number;
+}>>> & {
+    "onUpdate:modelValue"?: ((payload: number | undefined) => any) | undefined;
+}, {
+    defaultValue: number;
+    orientation: DataOrientation;
+    linear: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current step */
+        modelValue: number | undefined;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current step */
+        modelValue: number | undefined;
+    }) => 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/Stepper/StepperSeparator.d.ts

@@ -0,0 +1,29 @@
+import { SeparatorProps } from '../Separator';
+export interface StepperSeparatorProps extends SeparatorProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperSeparatorProps>, {}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperSeparatorProps>, {}>>>, {}, {}>, {
+    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/Stepper/StepperTitle.d.ts

@@ -0,0 +1,35 @@
+import { PrimitiveProps } from '../Primitive';
+export interface StepperTitleProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperTitleProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperTitleProps>, {
+    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/Stepper/StepperTrigger.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface StepperTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<StepperTriggerProps>, {
+    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/Stepper/index.d.ts

@@ -0,0 +1,7 @@
+export { default as StepperRoot, type StepperRootProps, type StepperRootEmits } from './StepperRoot';
+export { default as StepperItem, type StepperItemProps } from './StepperItem';
+export { default as StepperTrigger, type StepperTriggerProps } from './StepperTrigger';
+export { default as StepperDescription, type StepperDescriptionProps } from './StepperDescription';
+export { default as StepperTitle, type StepperTitleProps } from './StepperTitle';
+export { default as StepperIndicator, type StepperIndicatorProps } from './StepperIndicator';
+export { default as StepperSeparator, type StepperSeparatorProps } from './StepperSeparator';

package/dist/Switch/SwitchRoot.d.ts

@@ -0,0 +1,78 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+
+export interface SwitchRootProps extends PrimitiveProps {
+    /** The state of the switch when it is initially rendered. Use when you do not need to control its state. */
+    defaultValue?: boolean;
+    /** The controlled state of the switch. Can be bind as `v-model`. */
+    modelValue?: boolean;
+    /** When `true`, prevents the user from interacting with the switch. */
+    disabled?: boolean;
+    /** When `true`, indicates that the user must check the switch before the owning form can be submitted. */
+    required?: boolean;
+    /** The name of the switch. Submitted with its owning form as part of a name/value pair. */
+    name?: string;
+    id?: string;
+    /** The value given as data when submitted with a `name`. */
+    value?: string;
+}
+export type SwitchRootEmits = {
+    /** Event handler called when the value of the switch changes. */
+    'update:modelValue': [payload: boolean];
+};
+export interface SwitchRootContext {
+    modelValue?: Ref<boolean>;
+    toggleCheck: () => void;
+    disabled: Ref<boolean>;
+}
+export declare const injectSwitchRootContext: <T extends SwitchRootContext | null | undefined = SwitchRootContext>(fallback?: T | undefined) => T extends null ? SwitchRootContext | null : SwitchRootContext, provideSwitchRootContext: (contextValue: SwitchRootContext) => SwitchRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SwitchRootProps>, {
+    as: string;
+    modelValue: undefined;
+    value: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SwitchRootProps>, {
+    as: string;
+    modelValue: undefined;
+    value: string;
+}>>> & {
+    "onUpdate:modelValue"?: ((payload: boolean) => any) | undefined;
+}, {
+    value: string;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    modelValue: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current value */
+        modelValue: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current value */
+        modelValue: boolean;
+    }) => 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/Switch/SwitchThumb.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface SwitchThumbProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SwitchThumbProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<SwitchThumbProps>, {
+    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/Switch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SwitchRoot, type SwitchRootProps, type SwitchRootEmits, } from './SwitchRoot';
+export { default as SwitchThumb, type SwitchThumbProps, } from './SwitchThumb';

package/dist/Tabs/TabsContent.d.ts

@@ -0,0 +1,30 @@
+import { PrimitiveProps } from '../Primitive';
+import { StringOrNumber } from '../shared/types';
+
+export interface TabsContentProps extends PrimitiveProps {
+    /** A unique value that associates the content with a trigger. */
+    value: StringOrNumber;
+    /**
+     * Used to force mounting when more control is needed. Useful when
+     * controlling animation with Vue animation libraries.
+     */
+    forceMount?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<TabsContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<TabsContentProps>>>, {}, {}>, {
+    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/Tabs/TabsIndicator.d.ts

@@ -0,0 +1,22 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface TabsIndicatorProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<TabsIndicatorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<TabsIndicatorProps>>>, {}, {}>, {
+    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;
+    };
+};