@sakoa/ui 0.1.0

package/dist/components/ui/option/SOptionGroup.d.ts

@@ -0,0 +1,28 @@
+export interface Props {
+    label: string;
+    disabled?: boolean;
+    collapsible?: boolean;
+    defaultCollapsed?: boolean;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        label?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    disabled: boolean;
+    collapsible: boolean;
+    defaultCollapsed: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/option/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SOption } from './SOption';
+export { default as SOptionGroup } from './SOptionGroup';

package/dist/components/ui/otp/SOTP.d.ts

@@ -0,0 +1,122 @@
+import { SOTPVariant, SOTPSize, SOTPRounded, SOTPGap, SOTPMode, SOTPAnimation, SOTPEntryAnimation, SOTPInputAnimation, SOTPSuccessAnimation, SOTPErrorAnimation } from './types';
+export interface Props {
+    modelValue?: string;
+    maxlength?: number;
+    mode?: SOTPMode;
+    variant?: SOTPVariant;
+    size?: SOTPSize;
+    color?: string;
+    rounded?: SOTPRounded;
+    gap?: SOTPGap;
+    animation?: SOTPAnimation;
+    entryAnimation?: SOTPEntryAnimation;
+    inputAnimation?: SOTPInputAnimation;
+    successAnimation?: SOTPSuccessAnimation;
+    errorAnimation?: SOTPErrorAnimation;
+    morphText?: boolean;
+    morphDuration?: number;
+    showPlaceholder?: boolean;
+    placeholderChar?: string;
+    maskChar?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    error?: string | boolean;
+    success?: string | boolean;
+    autoFocus?: boolean;
+    autoSubmit?: boolean;
+    masked?: boolean;
+    clearOnError?: boolean;
+    allowPaste?: boolean;
+    separator?: string;
+    separatorPosition?: number[];
+    label?: string;
+    hint?: string;
+    errorMessage?: string;
+    successMessage?: string;
+    countdown?: number;
+    resendText?: string;
+    ariaLabel?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        resend?(_: {}): any;
+    };
+    refs: {
+        containerRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    clear: () => void;
+    focusInput: (index: number) => void;
+    focus: () => void;
+    blur: () => void | undefined;
+    triggerError: (message?: string) => void;
+    getValue: () => string;
+    isComplete: () => boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    input: (index: number, value: string) => any;
+    change: (value: string) => any;
+    blur: (index: number) => any;
+    focus: (index: number) => any;
+    error: (message: string) => any;
+    paste: (value: string) => any;
+    success: () => any;
+    complete: (value: string) => any;
+    resend: () => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onInput?: ((index: number, value: string) => any) | undefined;
+    onChange?: ((value: string) => any) | undefined;
+    onBlur?: ((index: number) => any) | undefined;
+    onFocus?: ((index: number) => any) | undefined;
+    onError?: ((message: string) => any) | undefined;
+    onPaste?: ((value: string) => any) | undefined;
+    onSuccess?: (() => any) | undefined;
+    onComplete?: ((value: string) => any) | undefined;
+    onResend?: (() => any) | undefined;
+}>, {
+    modelValue: string;
+    size: SOTPSize;
+    disabled: boolean;
+    mode: SOTPMode;
+    animation: SOTPAnimation;
+    color: string;
+    variant: SOTPVariant;
+    loading: boolean;
+    rounded: SOTPRounded;
+    separator: string;
+    gap: SOTPGap;
+    readonly: boolean;
+    maxlength: number;
+    autoFocus: boolean;
+    entryAnimation: SOTPEntryAnimation;
+    inputAnimation: SOTPInputAnimation;
+    successAnimation: SOTPSuccessAnimation;
+    errorAnimation: SOTPErrorAnimation;
+    morphText: boolean;
+    morphDuration: number;
+    showPlaceholder: boolean;
+    placeholderChar: string;
+    maskChar: string;
+    autoSubmit: boolean;
+    masked: boolean;
+    clearOnError: boolean;
+    allowPaste: boolean;
+    countdown: number;
+    resendText: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/otp/SOTPGroup.d.ts

@@ -0,0 +1,23 @@
+import { SOTPGap } from './types';
+interface Props {
+    gap?: SOTPGap;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    gap: SOTPGap;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/otp/SOTPSeparator.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/otp/SOTPSlot.d.ts

@@ -0,0 +1,49 @@
+import { SOTPVariant, SOTPSize, SOTPRounded, SOTPAnimation, SOTPEntryAnimation, SOTPInputAnimation, SOTPSuccessAnimation, SOTPErrorAnimation } from './types';
+interface Props {
+    index: number;
+    variant?: SOTPVariant;
+    size?: SOTPSize;
+    color?: string;
+    rounded?: SOTPRounded;
+    animation?: SOTPAnimation;
+    entryAnimation?: SOTPEntryAnimation;
+    inputAnimation?: SOTPInputAnimation;
+    successAnimation?: SOTPSuccessAnimation;
+    errorAnimation?: SOTPErrorAnimation;
+    morphText?: boolean;
+    morphDuration?: number;
+    showPlaceholder?: boolean;
+    placeholderChar?: string;
+    maskChar?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        placeholder?(_: {
+            index: number;
+            isFocused: boolean;
+            size: SOTPSize;
+        }): any;
+        mask?(_: {
+            index: number;
+            value: string;
+            size: SOTPSize;
+        }): any;
+        digit?(_: {
+            index: number;
+            value: string;
+            size: SOTPSize;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/otp/index.d.ts

@@ -0,0 +1,7 @@
+export { default as SOTP } from './SOTP';
+export { default as SOTPSlot } from './SOTPSlot';
+export { default as SOTPGroup } from './SOTPGroup';
+export { default as SOTPSeparator } from './SOTPSeparator';
+export { SOTP_INJECTION_KEY, useSOTPContext } from './useOTPContext';
+export type { SOTPContext, MorphData } from './useOTPContext';
+export type * from './types';

package/dist/components/ui/otp/types.d.ts

@@ -0,0 +1,26 @@
+export type SOTPVariant = 'outlined' | 'filled' | 'underlined' | 'ghost' | 'morphing';
+export type SOTPSize = 'small' | 'medium' | 'large' | 'xl';
+export type SOTPRounded = 'none' | 'sm' | 'md' | 'lg' | 'full';
+export type SOTPGap = 'tight' | 'normal' | 'wide';
+export type SOTPMode = 'numeric' | 'alphanumeric' | 'alphabetic' | 'any';
+export type SOTPAnimation = 'none' | 'bounce' | 'shake' | 'pulse' | 'flip' | 'morph' | 'glow' | 'wave';
+export type SOTPEntryAnimation = 'none' | 'fade' | 'slide-up' | 'slide-down' | 'scale' | 'rotate' | 'blur';
+export type SOTPInputAnimation = 'none' | 'pop' | 'squeeze' | 'jelly' | 'rubber';
+export type SOTPSuccessAnimation = 'none' | 'celebrate' | 'check' | 'ripple';
+export type SOTPErrorAnimation = 'none' | 'shake' | 'wobble' | 'flash';
+export interface SOTPVisualDefaults {
+    variant: SOTPVariant;
+    size: SOTPSize;
+    color: string;
+    rounded: SOTPRounded;
+    animation: SOTPAnimation;
+    entryAnimation: SOTPEntryAnimation;
+    inputAnimation: SOTPInputAnimation;
+    successAnimation: SOTPSuccessAnimation;
+    errorAnimation: SOTPErrorAnimation;
+    morphText: boolean;
+    morphDuration: number;
+    showPlaceholder: boolean;
+    placeholderChar: string;
+    maskChar: string;
+}

package/dist/components/ui/otp/useOTPContext.d.ts

@@ -0,0 +1,42 @@
+import { InjectionKey, Ref } from 'vue';
+import { SOTPMode, SOTPVisualDefaults } from './types';
+export interface MorphData {
+    from: string;
+    to: string;
+    progress: number;
+    phase: 'out' | 'in';
+}
+export interface SOTPContext {
+    digits: Ref<string[]>;
+    activeIndex: Ref<number>;
+    isComplete: Ref<boolean>;
+    showSuccess: Ref<boolean>;
+    showError: Ref<boolean>;
+    animatingIndices: Ref<Set<number>>;
+    morphingIndices: Ref<Map<number, MorphData>>;
+    maxlength: Readonly<Ref<number>>;
+    mode: Readonly<Ref<SOTPMode>>;
+    masked: Readonly<Ref<boolean>>;
+    disabled: Readonly<Ref<boolean>>;
+    readonly: Readonly<Ref<boolean>>;
+    loading: Readonly<Ref<boolean>>;
+    allowPaste: Readonly<Ref<boolean>>;
+    error: Readonly<Ref<string | boolean>>;
+    success: Readonly<Ref<string | boolean>>;
+    ariaLabel: Readonly<Ref<string>>;
+    defaults: Readonly<Ref<SOTPVisualDefaults>>;
+    inputPattern: Readonly<Ref<string>>;
+    inputMode: Readonly<Ref<string>>;
+    registerInput: (index: number, el: HTMLInputElement | null) => void;
+    handleInput: (event: Event, index: number) => void;
+    handleKeydown: (event: KeyboardEvent, index: number) => void;
+    handlePaste: (event: ClipboardEvent, index: number) => void;
+    handleFocus: (index: number) => void;
+    handleBlur: (index: number) => void;
+    focusInput: (index: number) => void;
+    startMorphAnimation: (index: number, from: string, to: string) => void;
+    getMorphStyle: (index: number) => Record<string, any>;
+    getDisplayChar: (index: number) => string;
+}
+export declare const SOTP_INJECTION_KEY: InjectionKey<SOTPContext>;
+export declare function useSOTPContext(): SOTPContext;

package/dist/components/ui/pagination/SPagination.d.ts

@@ -0,0 +1,151 @@
+export type PaginationVariant = 'default' | 'outlined' | 'ghost' | 'minimal' | 'dots';
+export type PaginationSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type PaginationShape = 'rounded' | 'square' | 'pill';
+export type AnimationType = 'none' | 'slide' | 'fade' | 'scale' | 'flip';
+export interface Props {
+    /** Current page (v-model) */
+    modelValue?: number;
+    /** Total number of items */
+    total: number;
+    /** Items per page */
+    pageSize?: number;
+    /** Maximum visible page buttons */
+    maxVisiblePages?: number;
+    /** Visual variant */
+    variant?: PaginationVariant;
+    /** Size of pagination buttons */
+    size?: PaginationSize;
+    /** Button shape */
+    shape?: PaginationShape;
+    /** Primary color */
+    color?: string;
+    /** Show first/last page buttons */
+    showFirstLast?: boolean;
+    /** Show prev/next buttons */
+    showPrevNext?: boolean;
+    /** Show total items info */
+    showTotal?: boolean;
+    /** Show quick jump input */
+    showQuickJump?: boolean;
+    /** Show page size selector */
+    showPageSize?: boolean;
+    /** Page size options for selector */
+    pageSizeOptions?: number[];
+    /** Disabled state */
+    disabled?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Animation type for page transitions */
+    animation?: AnimationType;
+    /** Show progress bar */
+    showProgress?: boolean;
+    /** Compact mode - combine prev/next into one button group */
+    compact?: boolean;
+    /** Simple mode - only shows prev/next with page info */
+    simple?: boolean;
+    /** Custom previous button text/icon */
+    prevText?: string;
+    /** Custom next button text/icon */
+    nextText?: string;
+    /** Custom first button text/icon */
+    firstText?: string;
+    /** Custom last button text/icon */
+    lastText?: string;
+    /** Enable keyboard navigation */
+    keyboard?: boolean;
+    /** Background for the container */
+    background?: boolean;
+    /** Hide single page */
+    hideSinglePage?: boolean;
+    /** Format for total text */
+    totalFormat?: (total: number, range: [number, number]) => string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        total?(_: {
+            total: number;
+            range: [number, number];
+        }): any;
+        pageSize?(_: {
+            size: number;
+            options: number[];
+            change: (event: Event) => void;
+        }): any;
+        prev?(_: {}): any;
+        prev?(_: {}): any;
+        'simple-content'?(_: {
+            current: number;
+            total: number;
+        }): any;
+        next?(_: {}): any;
+        next?(_: {}): any;
+        first?(_: {}): any;
+        ellipsis?(_: {}): any;
+        ellipsis?(_: {}): any;
+        page?(_: {
+            page: number;
+            active: boolean;
+        }): any;
+        last?(_: {}): any;
+        quickJump?(_: {
+            value: string;
+            jump: () => void;
+        }): any;
+    };
+    refs: {
+        ellipsisStartRef: HTMLDivElement;
+        ellipsisEndRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (page: number) => any;
+    change: (page: number) => any;
+    "update:pageSize": (size: number) => any;
+    pageSizeChange: (size: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((page: number) => any) | undefined;
+    onChange?: ((page: number) => any) | undefined;
+    "onUpdate:pageSize"?: ((size: number) => any) | undefined;
+    onPageSizeChange?: ((size: number) => any) | undefined;
+}>, {
+    modelValue: number;
+    size: PaginationSize;
+    disabled: boolean;
+    animation: AnimationType;
+    color: string;
+    variant: PaginationVariant;
+    loading: boolean;
+    showProgress: boolean;
+    compact: boolean;
+    background: boolean;
+    shape: PaginationShape;
+    pageSize: number;
+    maxVisiblePages: number;
+    showFirstLast: boolean;
+    showPrevNext: boolean;
+    showTotal: boolean;
+    showQuickJump: boolean;
+    showPageSize: boolean;
+    pageSizeOptions: number[];
+    simple: boolean;
+    prevText: string;
+    nextText: string;
+    firstText: string;
+    lastText: string;
+    keyboard: boolean;
+    hideSinglePage: boolean;
+    totalFormat: (total: number, range: [number, number]) => string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    ellipsisStartRef: HTMLDivElement;
+    ellipsisEndRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export { default as SPagination } from './SPagination';
+export type { PaginationVariant, PaginationSize, PaginationShape, AnimationType, Props as SPaginationProps } from './SPagination';

package/dist/components/ui/progress/SProgress.d.ts

@@ -0,0 +1,62 @@
+export interface Props {
+    modelValue?: number;
+    min?: number;
+    max?: number;
+    variant?: 'default' | 'gradient' | 'striped' | 'buffer' | 'segments' | 'liquid';
+    size?: 'xs' | 'small' | 'medium' | 'large' | 'xl';
+    orientation?: 'horizontal' | 'vertical';
+    rounded?: 'none' | 'sm' | 'md' | 'lg' | 'full';
+    color?: string;
+    trackColor?: string;
+    gradientColors?: string[];
+    bufferValue?: number;
+    bufferColor?: string;
+    segments?: number;
+    segmentGap?: number;
+    animated?: boolean;
+    animationType?: 'pulse' | 'wave' | 'shimmer' | 'bounce' | 'flow' | 'none';
+    animationSpeed?: 'slow' | 'normal' | 'fast';
+    indeterminate?: boolean;
+    showValue?: boolean;
+    valuePosition?: 'inside' | 'outside' | 'top' | 'tooltip';
+    valueFormat?: (value: number, min: number, max: number) => string;
+    label?: string;
+    labelPosition?: 'top' | 'bottom' | 'left' | 'right';
+    disabled?: boolean;
+    height?: string;
+    width?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    modelValue: number;
+    size: "xs" | "small" | "medium" | "large" | "xl";
+    animated: boolean;
+    disabled: boolean;
+    width: string;
+    label: string;
+    height: string;
+    color: string;
+    variant: "default" | "gradient" | "striped" | "buffer" | "segments" | "liquid";
+    rounded: "none" | "sm" | "md" | "lg" | "full";
+    animationType: "pulse" | "wave" | "shimmer" | "bounce" | "flow" | "none";
+    max: number;
+    indeterminate: boolean;
+    labelPosition: "top" | "bottom" | "left" | "right";
+    orientation: "horizontal" | "vertical";
+    min: number;
+    segments: number;
+    trackColor: string;
+    gradientColors: string[];
+    bufferValue: number;
+    bufferColor: string;
+    segmentGap: number;
+    animationSpeed: "slow" | "normal" | "fast";
+    showValue: boolean;
+    valuePosition: "inside" | "outside" | "top" | "tooltip";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    progressRef: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/components/ui/progress/SProgressRange.d.ts

@@ -0,0 +1,91 @@
+export interface RangeValue {
+    min: number;
+    max: number;
+}
+export interface Props {
+    modelValue?: number | RangeValue;
+    min?: number;
+    max?: number;
+    step?: number;
+    range?: boolean;
+    size?: 'small' | 'medium' | 'large';
+    orientation?: 'horizontal' | 'vertical';
+    rounded?: 'none' | 'sm' | 'md' | 'lg' | 'full';
+    color?: string;
+    trackColor?: string;
+    activeTrackColor?: string;
+    handleColor?: string;
+    showValue?: boolean;
+    showTooltip?: boolean;
+    tooltipPosition?: 'top' | 'bottom';
+    showTicks?: boolean;
+    tickCount?: number;
+    showLabels?: boolean;
+    valueFormat?: (value: number) => string;
+    minLabel?: string;
+    maxLabel?: string;
+    label?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    pushable?: number;
+    maxRange?: number;
+    swappable?: boolean;
+    lazy?: boolean;
+    marks?: {
+        value: number;
+        label?: string;
+    }[];
+    snap?: boolean;
+    handleSize?: number;
+    trackHeight?: number;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: number | RangeValue) => any;
+    change: (value: number | RangeValue) => any;
+    "drag-start": (handle: "max" | "single" | "min") => any;
+    "drag-end": (value: number | RangeValue) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number | RangeValue) => any) | undefined;
+    onChange?: ((value: number | RangeValue) => any) | undefined;
+    "onDrag-start"?: ((handle: "max" | "single" | "min") => any) | undefined;
+    "onDrag-end"?: ((value: number | RangeValue) => any) | undefined;
+}>, {
+    modelValue: number | RangeValue;
+    size: "small" | "medium" | "large";
+    disabled: boolean;
+    label: string;
+    color: string;
+    rounded: "none" | "sm" | "md" | "lg" | "full";
+    max: number;
+    range: boolean;
+    lazy: boolean;
+    orientation: "horizontal" | "vertical";
+    readonly: boolean;
+    min: number;
+    step: number;
+    snap: boolean;
+    trackColor: string;
+    showValue: boolean;
+    valueFormat: (value: number) => string;
+    showTooltip: boolean;
+    activeTrackColor: string;
+    handleColor: string;
+    tooltipPosition: "top" | "bottom";
+    showTicks: boolean;
+    tickCount: number;
+    showLabels: boolean;
+    minLabel: string;
+    maxLabel: string;
+    pushable: number;
+    maxRange: number;
+    swappable: boolean;
+    marks: {
+        value: number;
+        label?: string;
+    }[];
+    handleSize: number;
+    trackHeight: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    trackRef: HTMLDivElement;
+}, any>;
+export default _default;

package/dist/components/ui/progress/index.d.ts

@@ -0,0 +1,4 @@
+export { default as SProgress } from './SProgress';
+export { default as SProgressRange } from './SProgressRange';
+export type { Props as SProgressProps } from './SProgress';
+export type { Props as SProgressRangeProps, RangeValue } from './SProgressRange';