veload 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shehab Muhammed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,138 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# Veload
+
+Accessible loading UI for Vue 3: animated loaders, skeleton placeholders, progress indicators, and loading-state components with TypeScript support.
+
+## Key features
+
+- `VSpinner`, `VLoader`, and 36 individually importable loader components.
+- Skeleton primitives, patterns, and named layout presets.
+- Determinate and indeterminate progress indicators.
+- Loading overlays and a loading-aware button.
+- Composables for tracking, delaying, and grouping async loading states.
+- TypeScript declarations and a shared stylesheet.
+- Accessible status and progress semantics, plus reduced-motion support.
+- Vue components that can be rendered with Nuxt SSR.
+
+## Installation
+
+Veload requires Vue `^3.5.2` as a peer dependency.
+
+```bash
+npm install veload
+```
+
+Import the stylesheet once in your application entry point:
+
+```ts
+import "veload/style.css";
+```
+
+## Quick Start
+
+Use Veload in a Vue 3 + TypeScript single-file component. This example simulates an async operation; replace it with your application’s work.
+
+```vue
+<script setup lang="ts">
+import { ref } from "vue";
+import { VLoading, useLoading } from "veload";
+import "veload/style.css";
+
+const { isLoading, execute } = useLoading();
+const message = ref("Not loaded yet");
+
+async function load() {
+  await execute(async () => {
+    await new Promise<void>((resolve) => setTimeout(resolve, 400));
+    message.value = "Ready";
+  });
+}
+</script>
+
+<template>
+  <VLoading :loading="isLoading" label="Loading message">
+    <button type="button" @click="load">Load message</button>
+    <p>{{ message }}</p>
+  </VLoading>
+</template>
+```
+
+## Components and composables
+
+All components and composables are named exports from `veload`; there is no plugin to register with `app.use()`.
+
+**Loading and progress:** `VSpinner`, `VProgress`, `VLoading`, `VLoadingButton`.
+
+**Loader collection:** `VLoader` selects a treatment with its `variant` prop. Individual loader components are also exported:
+
+- **Motion:** `VBarsLoader`, `VBounceLoader`, `VDotsLoader`, `VDotSweepLoader`, `VEqualizerLoader`, `VSlidingBarsLoader`, `VSpinLoader`, `VSpinDotsLoader`, `VTypingLoader`, `VWaveLoader`.
+- **Circular:** `VBreathingLoader`, `VDualArcLoader`, `VGradientRingLoader`, `VOrbitDotsLoader`, `VOrbitLoader`, `VProgressRingLoader`, `VPulseLoader`, `VRingLoader`, `VRippleLoader`, `VRotateLoader`, `VSignalLoader`, `VSnakeLoader`.
+- **Geometric:** `VBlobLoader`, `VCardFlipLoader`, `VElementLoader`, `VFlowLoader`, `VGridLoader`, `VHashtagLoader`, `VHeatmapLoader`, `VLiquidLoader`, `VLogoSpinLoader`, `VMorphLoader`, `VPlaneLoader`, `VSquaresLoader`, `VStairLoader`.
+- **Utility:** `VFallbackLoader`.
+
+**Skeletons:** `VSkeleton` (`VSkeletonLoader` alias), `VPatternSkeleton`, `VSkeletonGroup`, `VSkeletonSwitch`, `VAutoSkeleton`, and the presets `VArticleSkeleton`, `VCardSkeleton`, `VDashboardSkeleton`, `VFeedSkeleton`, `VFormSkeleton`, `VListSkeleton`, `VMediaCardSkeleton`, `VProductCardSkeleton`, `VProfileSkeleton`, and `VTableSkeleton`.
+
+**Composables:** `useLoading()`, `useDelayedLoading(options?)`, and `useLoadingGroup(sources)`.
+
+## Usage examples
+
+### Loader and skeleton
+
+```vue
+<VSpinner :size="32" label="Loading products" />
+<VLoader variant="wave" label="Loading results" />
+<VSkeleton variant="rect" width="100%" height="8rem" />
+<VCardSkeleton />
+```
+
+### Progress
+
+```vue
+<VProgress :value="42" label="Uploading files" value-text="42%" />
+<VProgress label="Preparing download" />
+```
+
+Omit `value` for an indeterminate progress bar.
+
+### Loading-aware button
+
+```vue
+<VLoadingButton :loading="isSaving" type="submit">
+  Save changes
+</VLoadingButton>
+```
+
+### Delayed and grouped loading states
+
+```ts
+import { useDelayedLoading, useLoading, useLoadingGroup } from "veload";
+
+const search = useDelayedLoading({ delay: 200, minVisibleDuration: 300 });
+const products = useLoading();
+const categories = useLoading();
+const catalogLoading = useLoadingGroup([
+  products.isLoading,
+  categories.isLoading,
+]);
+
+await search.execute(() => fetchResults());
+```
+
+`useLoading()` tracks overlapping promises and exposes `isLoading`, `pendingCount`, and `execute`. `useDelayedLoading()` provides the same API with optional display delay and minimum visible duration. `useLoadingGroup()` derives a combined state from reactive loading sources.
+
+## Accessibility and reduced motion
+
+`VSpinner`, `VLoader`, and `VLoading` expose labeled status semantics. `VLoading` and `VLoadingButton` expose busy state, and determinate `VProgress` exposes its range and value. Skeletons are decorative and hidden from assistive technology by default, or can expose a status label. Loaders provide a `decorative` option when an ancestor already announces loading. Animations respect the user’s `prefers-reduced-motion` setting.
+
+## SSR compatibility
+
+Veload components can render with Vue SSR and Nuxt; they do not require a client-only wrapper. Create composables inside component setup rather than at module scope so mutable state is not shared between server requests. Use your framework’s server-aware data-fetching APIs for initial data; loading composables track async work but do not replace data fetching or hydration.
+
+## Playground and documentation
+
+Explore the components and examples in the [Veload playground](https://veload-playground.vercel.app). Browse the [installation guide](https://veload-playground.vercel.app/docs/installation), [API guide](https://veload-playground.vercel.app/docs/api), and [accessibility guide](https://veload-playground.vercel.app/docs/accessibility).
+
+The source repository is [Shehab-Mo/veload](https://github.com/Shehab-Mo/veload).
+
+## License
+
+[MIT](https://github.com/Shehab-Mo/veload/blob/main/pcakage/LICENSE)

package/dist/components/VLoader/index.vue.d.ts

@@ -0,0 +1,12 @@
+import { type VLoaderProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VLoaderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VLoaderProps> & Readonly<{}>, {
+    size: number;
+    color: string;
+    label: string;
+    decorative: boolean;
+    variant: "bars" | "blob" | "bounce" | "breathing" | "card-flip" | "dot-sweep" | "dots" | "dual-arc" | "element" | "equalizer" | "fallback" | "flow" | "gradient-ring" | "grid" | "hashtag" | "heatmap" | "liquid" | "logo-spin" | "morph" | "orbit-dots" | "orbit" | "plane" | "progress-ring" | "pulse" | "ring" | "ripple" | "rotate" | "signal" | "sliding-bars" | "snake" | "spin-dots" | "spin" | "squares" | "stair" | "typing" | "wave";
+    value: number | null;
+    duration: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VLoader/loaders.d.ts

@@ -0,0 +1,38 @@
+import { type DefineComponent } from "vue";
+import type { NamedLoaderProps } from "./types";
+export declare const VBarsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VBlobLoader: DefineComponent<NamedLoaderProps>;
+export declare const VBounceLoader: DefineComponent<NamedLoaderProps>;
+export declare const VBreathingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VCardFlipLoader: DefineComponent<NamedLoaderProps>;
+export declare const VDotSweepLoader: DefineComponent<NamedLoaderProps>;
+export declare const VDotsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VDualArcLoader: DefineComponent<NamedLoaderProps>;
+export declare const VElementLoader: DefineComponent<NamedLoaderProps>;
+export declare const VEqualizerLoader: DefineComponent<NamedLoaderProps>;
+export declare const VFallbackLoader: DefineComponent<NamedLoaderProps>;
+export declare const VFlowLoader: DefineComponent<NamedLoaderProps>;
+export declare const VGradientRingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VGridLoader: DefineComponent<NamedLoaderProps>;
+export declare const VHashtagLoader: DefineComponent<NamedLoaderProps>;
+export declare const VHeatmapLoader: DefineComponent<NamedLoaderProps>;
+export declare const VLiquidLoader: DefineComponent<NamedLoaderProps>;
+export declare const VLogoSpinLoader: DefineComponent<NamedLoaderProps>;
+export declare const VMorphLoader: DefineComponent<NamedLoaderProps>;
+export declare const VOrbitDotsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VOrbitLoader: DefineComponent<NamedLoaderProps>;
+export declare const VPlaneLoader: DefineComponent<NamedLoaderProps>;
+export declare const VProgressRingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VPulseLoader: DefineComponent<NamedLoaderProps>;
+export declare const VRingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VRippleLoader: DefineComponent<NamedLoaderProps>;
+export declare const VRotateLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSignalLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSlidingBarsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSnakeLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSpinDotsLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSpinLoader: DefineComponent<NamedLoaderProps>;
+export declare const VSquaresLoader: DefineComponent<NamedLoaderProps>;
+export declare const VStairLoader: DefineComponent<NamedLoaderProps>;
+export declare const VTypingLoader: DefineComponent<NamedLoaderProps>;
+export declare const VWaveLoader: DefineComponent<NamedLoaderProps>;

package/dist/components/VLoader/types.d.ts

@@ -0,0 +1,28 @@
+export declare const loaderVariants: readonly ["bars", "blob", "bounce", "breathing", "card-flip", "dot-sweep", "dots", "dual-arc", "element", "equalizer", "fallback", "flow", "gradient-ring", "grid", "hashtag", "heatmap", "liquid", "logo-spin", "morph", "orbit-dots", "orbit", "plane", "progress-ring", "pulse", "ring", "ripple", "rotate", "signal", "sliding-bars", "snake", "spin-dots", "spin", "squares", "stair", "typing", "wave"];
+export type LoaderVariant = (typeof loaderVariants)[number];
+export interface VLoaderProps {
+    /** Visual treatment used by the loader. */
+    variant?: LoaderVariant;
+    /** Primary color. @default "currentColor" */
+    color?: string;
+    /** Base size in pixels; repeated treatments may grow to fit count. @default 40 */
+    size?: number;
+    /** Animation duration in milliseconds. @default 1000 */
+    duration?: number;
+    /** Accessible name announced by the status region. @default "Loading" */
+    label?: string;
+    /** Hides the loader from assistive technology. @default false */
+    decorative?: boolean;
+    /** Repeated marks, rounded and clamped to 1–12. Fixed-shape treatments ignore it. @default 4 */
+    count?: number;
+    /** Optional completion value for the progress-ring treatment, from 0 to 100. */
+    value?: number | null;
+}
+export type NamedLoaderProps = Omit<VLoaderProps, "variant">;
+/** Props shared by treatments that render repeated marks. */
+export type VMarkLoaderProps = Omit<NamedLoaderProps, "value">;
+/** Props specific to the determinate or indeterminate progress-ring treatment. */
+export interface VProgressRingLoaderProps extends Omit<NamedLoaderProps, "value"> {
+    /** Completion percentage from 0 to 100. Omit for an indeterminate ring. */
+    value?: number | null;
+}

package/dist/components/VLoading/index.vue.d.ts

@@ -0,0 +1,21 @@
+import type { VLoadingProps } from "./types";
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    indicator?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VLoadingProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VLoadingProps> & Readonly<{}>, {
+    label: string;
+    loading: boolean;
+    inertContent: boolean;
+    indicatorSize: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/VLoading/types.d.ts

@@ -0,0 +1,27 @@
+export interface VLoadingProps {
+    /**
+     * Whether the loading overlay is active.
+     *
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Accessible loading message. The text is visually hidden by default.
+     *
+     * @default "Loading"
+     */
+    label?: string;
+    /**
+     * Makes the wrapped content inert while the overlay is active. This prevents
+     * pointer and keyboard interaction with content beneath the overlay.
+     *
+     * @default true
+     */
+    inertContent?: boolean;
+    /**
+     * Diameter of the default spinner in pixels.
+     *
+     * @default 28
+     */
+    indicatorSize?: number;
+}

package/dist/components/VLoadingButton/index.vue.d.ts

@@ -0,0 +1,21 @@
+import type { LoadingButtonType, VLoadingButtonProps } from "./types";
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    indicator?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VLoadingButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VLoadingButtonProps> & Readonly<{}>, {
+    type: LoadingButtonType;
+    loading: boolean;
+    indicatorSize: number;
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/VLoadingButton/types.d.ts

@@ -0,0 +1,29 @@
+export type LoadingButtonType = "button" | "submit" | "reset";
+export interface VLoadingButtonProps {
+    /**
+     * Whether the button is performing work. While loading, the button is
+     * disabled, exposes `aria-busy`, and shows an indicator.
+     *
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Native disabled state. The button is also disabled while loading.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Native button type. Defaults to `"button"` so the component does not
+     * accidentally submit a surrounding form.
+     *
+     * @default "button"
+     */
+    type?: LoadingButtonType;
+    /**
+     * Diameter of the default indicator in pixels.
+     *
+     * @default 16
+     */
+    indicatorSize?: number;
+}

package/dist/components/VPatternSkeleton/index.vue.d.ts

@@ -0,0 +1,18 @@
+import type { SkeletonPattern, VPatternSkeletonProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VPatternSkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VPatternSkeletonProps> & Readonly<{}>, {
+    pattern: SkeletonPattern;
+    animated: boolean;
+    rows: number;
+    columns: number;
+    showMedia: boolean;
+    showAvatar: boolean;
+    showHeader: boolean;
+    showChart: boolean;
+    showStats: boolean;
+    showSubmit: boolean;
+    showRating: boolean;
+    showPrice: boolean;
+    showCta: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VPatternSkeleton/presets.d.ts

@@ -0,0 +1,26 @@
+import { type DefineComponent } from "vue";
+import type { VSkeletonSwitchProps } from "../VSkeletonSwitch/types";
+import type { VArticleSkeletonProps, VCardSkeletonProps, VDashboardSkeletonProps, VFeedSkeletonProps, VFormSkeletonProps, VListSkeletonProps, VMediaCardSkeletonProps, VProductCardSkeletonProps, VProfileSkeletonProps, VTableSkeletonProps } from "./types";
+export declare const VSkeletonLoader: DefineComponent<import("../VSkeleton/types.js").VSkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("../VSkeleton/types.js").VSkeletonProps> & Readonly<{}>, {
+    variant: import("../VSkeleton/types.js").SkeletonVariant;
+    animated: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export declare const VArticleSkeleton: DefineComponent<VArticleSkeletonProps>;
+export declare const VCardSkeleton: DefineComponent<VCardSkeletonProps>;
+export declare const VDashboardSkeleton: DefineComponent<VDashboardSkeletonProps>;
+export declare const VFeedSkeleton: DefineComponent<VFeedSkeletonProps>;
+export declare const VFormSkeleton: DefineComponent<VFormSkeletonProps>;
+export declare const VListSkeleton: DefineComponent<VListSkeletonProps>;
+export declare const VMediaCardSkeleton: DefineComponent<VMediaCardSkeletonProps>;
+export declare const VProductCardSkeleton: DefineComponent<VProductCardSkeletonProps>;
+export declare const VProfileSkeleton: DefineComponent<VProfileSkeletonProps>;
+export declare const VTableSkeleton: DefineComponent<VTableSkeletonProps>;
+/**
+ * A safe content switcher for Vue skeleton states.
+ *
+ * Unlike React Loadly's experimental DOM-inference API, this component never
+ * executes or inspects slot content. It renders a supplied skeleton slot or a
+ * selected Veload pattern while loading, then renders the default slot.
+ */
+export type VAutoSkeletonProps = VSkeletonSwitchProps;
+export declare const VAutoSkeleton: DefineComponent<VAutoSkeletonProps>;

package/dist/components/VPatternSkeleton/types.d.ts

@@ -0,0 +1,48 @@
+export type SkeletonPattern = "lines" | "article" | "card" | "profile" | "list" | "table" | "media" | "form" | "dashboard" | "feed" | "product";
+export interface SkeletonAppearanceProps {
+    color?: string;
+    highlightColor?: string;
+    animated?: boolean;
+    label?: string;
+}
+export interface VPatternSkeletonProps extends SkeletonAppearanceProps {
+    /** Layout pattern. @default "lines" */
+    pattern?: SkeletonPattern;
+    /** Repeated lines, items, fields, or data rows (1–12). Table/dashboard headers are separate; dashboard always includes one header. @default 3 */
+    rows?: number;
+    /** Table column count. @default 3 */
+    columns?: number;
+    /** Image or media height in pixels or a CSS length. */
+    mediaHeight?: number | string;
+    /** Avatar diameter in pixels. */
+    avatarSize?: number;
+    /** Enables optional media blocks where the pattern supports them. @default true */
+    showMedia?: boolean;
+    /** Enables optional avatar blocks where the pattern supports them. @default true */
+    showAvatar?: boolean;
+    /** Enables a table header. @default true */
+    showHeader?: boolean;
+    /** Enables the dashboard chart block. @default true */
+    showChart?: boolean;
+    /** Enables profile or dashboard statistic blocks. @default true */
+    showStats?: boolean;
+    /** Enables the form submit block. @default true */
+    showSubmit?: boolean;
+    /** Enables the product rating block. @default true */
+    showRating?: boolean;
+    /** Enables the product price block. @default true */
+    showPrice?: boolean;
+    /** Enables the product call-to-action block. @default true */
+    showCta?: boolean;
+}
+export type NamedSkeletonProps = Omit<VPatternSkeletonProps, "pattern">;
+export type VArticleSkeletonProps = Pick<NamedSkeletonProps, "rows" | "mediaHeight" | "showMedia"> & SkeletonAppearanceProps;
+export type VCardSkeletonProps = Pick<NamedSkeletonProps, "rows" | "mediaHeight" | "showMedia" | "showAvatar"> & SkeletonAppearanceProps;
+export type VDashboardSkeletonProps = Pick<NamedSkeletonProps, "rows" | "columns" | "showChart" | "showStats"> & SkeletonAppearanceProps;
+export type VFeedSkeletonProps = Pick<NamedSkeletonProps, "rows" | "showAvatar"> & SkeletonAppearanceProps;
+export type VFormSkeletonProps = Pick<NamedSkeletonProps, "rows" | "showSubmit"> & SkeletonAppearanceProps;
+export type VListSkeletonProps = Pick<NamedSkeletonProps, "rows" | "showAvatar" | "avatarSize"> & SkeletonAppearanceProps;
+export type VMediaCardSkeletonProps = Pick<NamedSkeletonProps, "rows" | "mediaHeight"> & SkeletonAppearanceProps;
+export type VProductCardSkeletonProps = Pick<NamedSkeletonProps, "mediaHeight" | "showRating" | "showPrice" | "showCta"> & SkeletonAppearanceProps;
+export type VProfileSkeletonProps = Pick<NamedSkeletonProps, "rows" | "avatarSize" | "showStats"> & SkeletonAppearanceProps;
+export type VTableSkeletonProps = Pick<NamedSkeletonProps, "rows" | "columns" | "showHeader"> & SkeletonAppearanceProps;

package/dist/components/VProgress/index.vue.d.ts

@@ -0,0 +1,10 @@
+import type { VProgressProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VProgressProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VProgressProps> & Readonly<{}>, {
+    label: string;
+    height: string | number;
+    value: number | null;
+    min: number;
+    max: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VProgress/types.d.ts

@@ -0,0 +1,45 @@
+export interface VProgressProps {
+    /**
+     * Current progress value. Omit, pass `null`, or pass a non-finite value to
+     * render an indeterminate progress bar.
+     */
+    value?: number | null;
+    /**
+     * Lower bound of the value range.
+     *
+     * @default 0
+     */
+    min?: number;
+    /**
+     * Upper bound of the value range. When `max` is not greater than `min`, the
+     * bar renders as indeterminate.
+     *
+     * @default 100
+     */
+    max?: number;
+    /**
+     * Accessible name for the progress bar.
+     *
+     * @default "Progress"
+     */
+    label?: string;
+    /**
+     * Optional human-readable value text, for example `"3 of 10 files"`.
+     * Only applied while determinate.
+     */
+    valueText?: string;
+    /**
+     * Thickness of the bar as a pixel number or any CSS length.
+     *
+     * @default 8
+     */
+    height?: number | string;
+    /**
+     * Color of the filled portion. Overrides `--v-progress-color`.
+     */
+    color?: string;
+    /**
+     * Color of the unfilled track. Overrides `--v-progress-track-color`.
+     */
+    trackColor?: string;
+}

package/dist/components/VSkeleton/index.vue.d.ts

@@ -0,0 +1,7 @@
+import type { SkeletonVariant, VSkeletonProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VSkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VSkeletonProps> & Readonly<{}>, {
+    variant: SkeletonVariant;
+    animated: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/VSkeleton/types.d.ts

@@ -0,0 +1,37 @@
+export type SkeletonVariant = "text" | "rect" | "circle";
+export interface VSkeletonProps {
+    /**
+     * Shape of the placeholder.
+     *
+     * @default "text"
+     */
+    variant?: SkeletonVariant;
+    /**
+     * Width as a pixel number or any CSS length. Defaults to `100%`, except for
+     * circular skeletons, which default to `40px`.
+     */
+    width?: number | string;
+    /**
+     * Height as a pixel number or any CSS length. Circular skeletons use a
+     * square aspect ratio when no height is supplied.
+     */
+    height?: number | string;
+    /**
+     * Border radius as a pixel number or any CSS length. When omitted, a shape
+     * appropriate default is used.
+     */
+    borderRadius?: number | string;
+    /**
+     * Enables the shimmer animation. Reduced-motion preferences always disable
+     * the animation in CSS.
+     *
+     * @default true
+     */
+    animated?: boolean;
+    /**
+     * Optional accessible name. When supplied, the skeleton becomes a
+     * `role="status"` placeholder. When omitted, it is decorative and hidden
+     * from assistive technology.
+     */
+    label?: string;
+}

package/dist/components/VSkeletonGroup/index.vue.d.ts

@@ -0,0 +1,17 @@
+import type { VSkeletonGroupProps } from "./types";
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VSkeletonGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VSkeletonGroupProps> & Readonly<{}>, {
+    decorative: boolean;
+    gap: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/VSkeletonGroup/types.d.ts

@@ -0,0 +1,8 @@
+export interface VSkeletonGroupProps {
+    /** Accessible loading message for the complete group. */
+    label?: string;
+    /** CSS gap between child placeholders. @default "0.75rem" */
+    gap?: string;
+    /** Hides the entire group from assistive technology. @default false */
+    decorative?: boolean;
+}

package/dist/components/VSkeletonSwitch/index.vue.d.ts

@@ -0,0 +1,31 @@
+import type { VSkeletonSwitchProps } from "./types";
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    skeleton?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<VSkeletonSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VSkeletonSwitchProps> & Readonly<{}>, {
+    label: string;
+    pattern: import("../VPatternSkeleton/types.js").SkeletonPattern;
+    animated: boolean;
+    loading: boolean;
+    rows: number;
+    showMedia: boolean;
+    showAvatar: boolean;
+    showHeader: boolean;
+    showChart: boolean;
+    showStats: boolean;
+    showSubmit: boolean;
+    showRating: boolean;
+    showPrice: boolean;
+    showCta: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/VSkeletonSwitch/types.d.ts

@@ -0,0 +1,5 @@
+import type { VPatternSkeletonProps } from "../VPatternSkeleton/types";
+export interface VSkeletonSwitchProps extends VPatternSkeletonProps {
+    /** Whether to show the skeleton slot or pattern. @default true */
+    loading?: boolean;
+}

package/dist/components/VSpinner/index.vue.d.ts

@@ -0,0 +1,9 @@
+import type { VSpinnerProps } from "./types";
+declare const __VLS_export: import("vue").DefineComponent<VSpinnerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<VSpinnerProps> & Readonly<{}>, {
+    size: number;
+    color: string;
+    label: string;
+    decorative: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;