hys-ui 0.6.0 → 0.7.0

package/dist/types/components/HysIcon/builtins/technology.d.ts

@@ -0,0 +1,18 @@
+export declare const devicesIcons: {
+    monitor: import("../iconTypes").HysIconEntry;
+    laptop: import("../iconTypes").HysIconEntry;
+    tablet: import("../iconTypes").HysIconEntry;
+    smartphone: import("../iconTypes").HysIconEntry;
+    battery: import("../iconTypes").HysIconEntry;
+    "battery-charging": import("../iconTypes").HysIconEntry;
+    wifi: import("../iconTypes").HysIconEntry;
+    "wifi-off": import("../iconTypes").HysIconEntry;
+    signal: import("../iconTypes").HysIconEntry;
+    bluetooth: import("../iconTypes").HysIconEntry;
+    cloud: import("../iconTypes").HysIconEntry;
+    "cloud-upload": import("../iconTypes").HysIconEntry;
+    "cloud-download": import("../iconTypes").HysIconEntry;
+    server: import("../iconTypes").HysIconEntry;
+    "hard-drive": import("../iconTypes").HysIconEntry;
+    terminal: import("../iconTypes").HysIconEntry;
+};

package/dist/types/components/HysIcon/iconBuiltins.d.ts

@@ -0,0 +1,2 @@
+import type { HysIconLibrary } from "./iconTypes";
+export declare const hysBuiltinIcons: HysIconLibrary;

package/dist/types/components/HysIcon/iconConfig.d.ts

@@ -0,0 +1,10 @@
+import { type ComputedRef } from "vue";
+import type { HysIconConfig, HysIconProps, HysIconRegistry } from "./iconTypes";
+interface IconScope {
+    registry: ComputedRef<HysIconRegistry>;
+    defaults: ComputedRef<Partial<HysIconProps>>;
+}
+export declare function configureHysIcon(config: HysIconConfig): void;
+export declare function useIconConfig(): IconScope;
+export declare function provideHysIcons(config: HysIconConfig): void;
+export {};

package/dist/types/components/HysIcon/iconRegistry.d.ts

@@ -0,0 +1,5 @@
+import type { HysIconRegistry } from "./iconTypes";
+export declare function createHysIconRegistry(options?: {
+    builtins?: boolean;
+}): HysIconRegistry;
+export declare const hysIconRegistry: HysIconRegistry;

package/dist/types/components/HysIcon/iconSafety.d.ts

@@ -0,0 +1,8 @@
+import type { HysIconSvg, HysIconSvgNode } from "./iconTypes";
+export declare function iconViewBox(value?: string): string;
+export declare function iconPaint(value: string): string | undefined;
+export declare function sanitizeIconNodes(nodes: readonly HysIconSvgNode[], prefix?: string): HysIconSvgNode[];
+export declare function importHysIconSvg(markup: string): HysIconSvg;
+export declare function iconAssetUrl(value: string, allowedOrigins?: readonly string[], fragment?: boolean): string | undefined;
+export declare function iconSrcset(value: string | undefined, allowedOrigins?: readonly string[]): string | undefined;
+export declare function serializeHysIconSvg(source: HysIconSvg): string;

package/dist/types/components/HysIcon/iconStyle.d.ts

@@ -0,0 +1,6 @@
+import type { CSSProperties } from "vue";
+import type { HysIconAnimation, HysIconProps } from "./iconTypes";
+export declare const iconLength: (value: number | string | undefined) => string | undefined;
+export declare function iconNumber(value: number | undefined, fallback: number, min: number, max: number): number;
+export declare const hysIconAnimations: readonly ["none", "spin", "rotate", "pulse", "bounce", "shake", "swing", "wiggle", "float", "breathing", "scale", "fade", "slide", "flip", "spring", "heartbeat", "blink", "draw", "morph", "gradient", "loading"];
+export declare function iconStyle(options: HysIconProps, animation: HysIconAnimation, paused: boolean): CSSProperties;

package/dist/types/components/HysIcon/iconTypes.d.ts

@@ -0,0 +1,192 @@
+import type { Component, CSSProperties, MaybeRefOrGetter, Ref } from "vue";
+import type { HysTheme } from "../../config";
+export type HysIconVariant = "outline" | "filled" | "duotone" | "multicolor" | "round" | "sharp" | "bold" | "thin" | "gradient" | "flat" | "3d" | (string & {});
+export type HysIconStatus = "default" | "loading" | "success" | "error" | "warning" | "info" | (string & {});
+export type HysIconAnimation = "none" | "spin" | "rotate" | "pulse" | "bounce" | "shake" | "swing" | "wiggle" | "float" | "breathing" | "scale" | "fade" | "slide" | "flip" | "spring" | "heartbeat" | "blink" | "draw" | "morph" | "gradient" | "loading" | (string & {});
+export interface HysIconSvgNode {
+    tag: string;
+    attrs?: Record<string, string | number>;
+    children?: readonly HysIconSvgNode[];
+}
+export interface HysIconSvg {
+    type: "svg";
+    viewBox?: string;
+    nodes: readonly HysIconSvgNode[];
+}
+export type HysIconSource = HysIconSvg | {
+    type: "sprite";
+    href: string;
+    viewBox?: string;
+} | {
+    type: "image";
+    src: string;
+    srcset?: string;
+} | {
+    type: "font";
+    glyph?: string;
+    family?: string;
+    className?: string;
+} | {
+    type: "text";
+    text: string;
+} | {
+    type: "component";
+    component: Component;
+    props?: Record<string, unknown>;
+};
+export type HysIconLoader = () => Promise<HysIconSource | {
+    default: HysIconSource;
+}> | HysIconSource;
+export type HysIconAsset = HysIconSource | HysIconLoader;
+export interface HysIconEntry {
+    source?: HysIconAsset;
+    variants?: Record<string, HysIconAsset>;
+    label?: string;
+    category?: string;
+    keywords?: readonly string[];
+    aliases?: readonly string[];
+    directional?: boolean;
+}
+export interface HysIconLibrary {
+    namespace: string;
+    version?: string;
+    icons: Record<string, HysIconAsset | HysIconEntry>;
+}
+export type HysIconConflict = "error" | "replace" | "keep";
+export interface HysIconRecord {
+    name: string;
+    label: string;
+    namespace: string;
+    version?: string;
+    category: string;
+    variants: readonly string[];
+    aliases: readonly string[];
+    keywords: readonly string[];
+    directional: boolean;
+}
+export interface HysIconSearch {
+    namespace?: string;
+    category?: string;
+    variant?: string;
+    fuzzy?: boolean;
+}
+export interface HysIconRegistry {
+    readonly revision: Readonly<Ref<number>>;
+    register(library: HysIconLibrary, conflict?: HysIconConflict): void;
+    unregister(namespace: string): void;
+    resolve(name: string): HysIconRecord | undefined;
+    get(name: string, variant?: HysIconVariant): HysIconSource | undefined;
+    load(name: string, variant?: HysIconVariant): Promise<HysIconSource>;
+    preload(names: readonly string[], variant?: HysIconVariant, allowedOrigins?: readonly string[]): Promise<PromiseSettledResult<HysIconSource>[]>;
+    list(): HysIconRecord[];
+    search(query: string, filter?: HysIconSearch): HysIconRecord[];
+}
+export type HysIconReference = string | HysIconSource;
+export interface HysIconLayer {
+    icon: HysIconReference;
+    color?: string;
+    size?: number | string;
+    x?: number | string;
+    y?: number | string;
+    rotate?: number;
+}
+export interface HysIconProps {
+    name?: string;
+    source?: HysIconSource;
+    variant?: HysIconVariant;
+    registry?: HysIconRegistry;
+    status?: HysIconStatus;
+    statusIcons?: Record<string, HysIconReference>;
+    fallback?: HysIconReference | false;
+    loadingIcon?: HysIconReference | false;
+    size?: number | string;
+    width?: number | string;
+    height?: number | string;
+    fit?: "contain" | "cover" | "fill";
+    color?: string;
+    theme?: HysTheme | "system";
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    gradient?: readonly string[];
+    opacity?: number;
+    background?: string;
+    shape?: "circle" | "square" | "rounded";
+    radius?: number | string;
+    border?: string;
+    padding?: number | string;
+    gap?: number | string;
+    shadow?: string;
+    glow?: string;
+    rotate?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+    align?: "start" | "center" | "end";
+    verticalAlign?: CSSProperties["verticalAlign"];
+    directional?: boolean;
+    animation?: HysIconAnimation;
+    animateOn?: "always" | "hover" | "click" | "state";
+    animated?: boolean;
+    paused?: boolean;
+    duration?: number;
+    speed?: number;
+    animationDelay?: number;
+    iterations?: number | "infinite";
+    easing?: string;
+    morphTo?: string;
+    animationStyle?: CSSProperties;
+    decorative?: boolean;
+    label?: string;
+    clickable?: boolean;
+    href?: string;
+    target?: string;
+    rel?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    active?: boolean;
+    selected?: boolean;
+    tooltip?: string;
+    badge?: number | string | boolean;
+    badgePosition?: "top-start" | "top-end" | "bottom-start" | "bottom-end";
+    badgeMax?: number;
+    secondary?: HysIconReference;
+    layers?: readonly HysIconLayer[];
+    allowedOrigins?: readonly string[];
+    picker?: boolean;
+    allowUpload?: boolean;
+    storageKey?: string;
+    pickerLocale?: Partial<HysIconPickerLocale>;
+}
+export interface HysIconPickerLocale {
+    search: string;
+    library: string;
+    category: string;
+    variant: string;
+    all: string;
+    favorites: string;
+    recent: string;
+    popular: string;
+    empty: string;
+    previous: string;
+    next: string;
+    addFavorite: string;
+    removeFavorite: string;
+    copyName: string;
+    copyCode: string;
+    copySvg: string;
+    copied: string;
+    copyFailed: string;
+    upload: string;
+    imported: (count: number) => string;
+}
+export interface HysIconConfig {
+    registry?: HysIconRegistry;
+    defaults?: MaybeRefOrGetter<Partial<HysIconProps>>;
+}
+export interface HysIconContext {
+    name?: string;
+    status: HysIconStatus;
+    variant: HysIconVariant;
+    loading: boolean;
+    source?: HysIconSource;
+}

package/dist/types/components/HysIcon/useIconResource.d.ts

@@ -0,0 +1,14 @@
+import type { HysIconReference, HysIconRegistry, HysIconSource } from "./iconTypes";
+export declare function useIconResource(options: {
+    reference(): HysIconReference | undefined;
+    registry(): HysIconRegistry;
+    variant(): string;
+    allowedOrigins?(): readonly string[] | undefined;
+}): {
+    source: import("vue").ShallowRef<HysIconSource | undefined, HysIconSource | undefined>;
+    loading: import("vue").ShallowRef<boolean, boolean>;
+    error: import("vue").ShallowRef<unknown, unknown>;
+    record: import("vue").ComputedRef<import("./iconTypes").HysIconRecord | undefined>;
+    fail: (reason: unknown) => void;
+    reload: () => void;
+};

package/dist/types/components/HysPopconfirm/HysPopconfirm.vue.d.ts

@@ -0,0 +1,85 @@
+import type { HysPopconfirmAction, HysPopconfirmActionContext, HysPopconfirmDismissReason, HysPopconfirmProps, HysPopconfirmSlots } from "./popconfirmTypes";
+type __VLS_Slots = HysPopconfirmSlots;
+declare function clearError(): void;
+declare function close(): Promise<boolean>;
+declare const __VLS_base: import("vue").DefineComponent<HysPopconfirmProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    referenceElement: import("vue").ComputedRef<HTMLElement | undefined>;
+    open: import("vue").Ref<boolean, boolean>;
+    placement: import("vue").Ref<import("../..").Placement, import("../..").Placement>;
+    show: () => Promise<boolean>;
+    close: typeof close;
+    hide: typeof close;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+    focus: () => void | undefined;
+    confirm: (event?: Event) => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    abort: () => void;
+    pending: import("vue").ComputedRef<HysPopconfirmAction | null>;
+    error: import("vue").Ref<string, string>;
+    clearError: typeof clearError;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (open: boolean) => any;
+    visibleChange: (open: boolean) => any;
+    show: () => any;
+    cancel: (context: HysPopconfirmActionContext) => any;
+    error: (error: unknown, context: HysPopconfirmActionContext) => any;
+    hide: () => any;
+    "update:open": (open: boolean) => any;
+    opened: () => any;
+    closed: () => any;
+    openChange: (open: boolean) => any;
+    confirm: (result: unknown, context: HysPopconfirmActionContext) => any;
+    dismiss: (reason: HysPopconfirmDismissReason) => any;
+}, string, import("vue").PublicProps, Readonly<HysPopconfirmProps> & Readonly<{
+    "onUpdate:modelValue"?: ((open: boolean) => any) | undefined;
+    onVisibleChange?: ((open: boolean) => any) | undefined;
+    onShow?: (() => any) | undefined;
+    onCancel?: ((context: HysPopconfirmActionContext) => any) | undefined;
+    onError?: ((error: unknown, context: HysPopconfirmActionContext) => any) | undefined;
+    onHide?: (() => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onOpened?: (() => any) | undefined;
+    onClosed?: (() => any) | undefined;
+    onOpenChange?: ((open: boolean) => any) | undefined;
+    onConfirm?: ((result: unknown, context: HysPopconfirmActionContext) => any) | undefined;
+    onDismiss?: ((reason: HysPopconfirmDismissReason) => any) | undefined;
+}>, {
+    icon: false | import("vue").Component;
+    modelValue: boolean;
+    size: import("../..").HysButtonSize;
+    showArrow: boolean;
+    trigger: "click" | "contextmenu" | "manual";
+    destroyOnHide: boolean;
+    title: string;
+    offset: number;
+    tone: import("./popconfirmTypes").HysPopconfirmTone;
+    showIcon: boolean;
+    open: boolean;
+    placement: import("../..").Placement;
+    maxWidth: string | number;
+    appendTo: string | false | HTMLElement;
+    confirmText: string;
+    cancelText: string;
+    autoAdjustOverflow: boolean;
+    closeOnEscape: boolean;
+    closeOnOutside: boolean;
+    align: "center" | "end" | "start";
+    initialFocus: "none" | "cancel" | "panel" | "confirm";
+    restoreFocus: boolean;
+    showCancel: boolean;
+    closeOnConfirm: boolean;
+    triggerText: string;
+    pendingText: string;
+    cancelVariant: import("../..").HysButtonVariant;
+    closeOnCancel: 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/types/components/HysPopconfirm/popconfirmTypes.d.ts

@@ -0,0 +1,72 @@
+import type { Component, VNodeChild } from "vue";
+import type { HysButtonSize, HysButtonVariant } from "../HysButton/HysButton.vue";
+import type { HysPopupSurfaceContext, HysPopupSurfaceInstance, HysPopupSurfaceProps } from "../../composables/popupSurface";
+import type { PopupCloseSource } from "../../composables/usePopupSurfaceInteractions";
+export type HysPopconfirmTone = "neutral" | "info" | "success" | "warning" | "danger";
+export type HysPopconfirmAction = "confirm" | "cancel";
+export type HysPopconfirmDismissReason = Exclude<PopupCloseSource, "auto">;
+export interface HysPopconfirmActionContext {
+    action: HysPopconfirmAction;
+    signal: AbortSignal;
+    event?: Event;
+}
+export type HysPopconfirmGuard = (context: HysPopconfirmActionContext) => boolean | void | PromiseLike<boolean | void>;
+export type HysPopconfirmHandler = (context: HysPopconfirmActionContext) => unknown;
+export interface HysPopconfirmProps extends Omit<HysPopupSurfaceProps, "autoClose" | "enterable" | "showDelay" | "hideDelay" | "trigger"> {
+    trigger?: "click" | "contextmenu" | "manual";
+    triggerText?: string;
+    title?: string;
+    description?: string;
+    tone?: HysPopconfirmTone;
+    icon?: Component | false;
+    showIcon?: boolean;
+    confirmText?: string;
+    cancelText?: string;
+    pendingText?: string;
+    errorText?: string | ((error: unknown, context: HysPopconfirmActionContext) => string);
+    confirmVariant?: HysButtonVariant;
+    cancelVariant?: HysButtonVariant;
+    size?: HysButtonSize;
+    align?: "start" | "center" | "end";
+    showCancel?: boolean;
+    confirmDisabled?: boolean;
+    cancelDisabled?: boolean;
+    loading?: boolean;
+    allowCancelWhilePending?: boolean;
+    dismissWhilePending?: boolean;
+    closeOnConfirm?: boolean;
+    closeOnCancel?: boolean;
+    initialFocus?: "cancel" | "confirm" | "panel" | "none";
+    restoreFocus?: boolean;
+    beforeConfirm?: HysPopconfirmGuard;
+    beforeCancel?: HysPopconfirmGuard;
+    action?: HysPopconfirmHandler;
+}
+export interface HysPopconfirmContext extends HysPopupSurfaceContext {
+    pending: HysPopconfirmAction | null;
+    busy: boolean;
+    disabled: boolean;
+    confirmDisabled: boolean;
+    cancelDisabled: boolean;
+    error: string;
+    confirm: (event?: Event) => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    abort: () => void;
+}
+export interface HysPopconfirmSlots {
+    default?: (context: HysPopconfirmContext) => VNodeChild;
+    trigger?: (context: HysPopconfirmContext) => VNodeChild;
+    title?: (context: HysPopconfirmContext) => VNodeChild;
+    description?: (context: HysPopconfirmContext) => VNodeChild;
+    icon?: (context: HysPopconfirmContext) => VNodeChild;
+    actions?: (context: HysPopconfirmContext) => VNodeChild;
+    error?: (context: HysPopconfirmContext) => VNodeChild;
+}
+export interface HysPopconfirmInstance extends HysPopupSurfaceInstance {
+    readonly pending: HysPopconfirmAction | null;
+    readonly error: string;
+    confirm: (event?: Event) => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    abort: () => void;
+    clearError: () => void;
+}

package/dist/types/components/HysPopconfirm/usePopconfirmAction.d.ts

@@ -0,0 +1,6 @@
+import type { HysPopconfirmAction, HysPopconfirmActionContext } from "./popconfirmTypes";
+export declare function usePopconfirmAction(): {
+    pending: import("vue").Ref<HysPopconfirmAction | null, HysPopconfirmAction | null>;
+    run: (action: HysPopconfirmAction, event: Event | undefined, work: (context: HysPopconfirmActionContext) => unknown, finish: (result: unknown, context: HysPopconfirmActionContext, isCurrent: () => boolean) => Promise<void>, fail: (error: unknown, context: HysPopconfirmActionContext) => void) => Promise<boolean>;
+    abort: () => void;
+};

package/dist/types/components/HysProgress/HysProgress.vue.d.ts

@@ -12,10 +12,10 @@ declare const __VLS_base: import("vue").DefineComponent<HysProgressProps, {
     status: import("../..").HysProgressStatus;
     strokeLinecap: import("../..").HysProgressLinecap;
     showLabel: boolean;
+    animated: boolean;
     showStatusIcon: boolean;
     stepGap: number;
     gapPosition: import("../..").HysProgressGapPosition;
-    animated: boolean;
     flowDuration: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/types/components/HysResult/HysResult.vue.d.ts

@@ -0,0 +1,22 @@
+import type { HysResultProps, HysResultSlots } from "./resultTypes";
+type __VLS_Slots = HysResultSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysResultProps, {
+    element: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    focus: (options?: FocusOptions) => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HysResultProps> & Readonly<{}>, {
+    icon: false | import("vue").Component;
+    size: "sm" | "md" | "lg";
+    status: import("./resultTypes").HysResultStatus;
+    announce: "off" | "polite" | "assertive";
+    align: "center" | "start";
+    showCode: boolean;
+    headingLevel: 2 | 3 | 4 | 5 | 6;
+}, {}, {}, {}, 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/types/components/HysResult/resultTypes.d.ts

@@ -0,0 +1,32 @@
+import type { Component, VNodeChild } from "vue";
+export type HysResultCode = "403" | "404" | "500";
+export type HysResultStatus = "primary" | "info" | "success" | "warning" | "error" | HysResultCode | 403 | 404 | 500;
+export interface HysResultProps {
+    status?: HysResultStatus;
+    title?: string;
+    subtitle?: string;
+    icon?: Component | false;
+    showCode?: boolean;
+    size?: "sm" | "md" | "lg";
+    align?: "start" | "center";
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    announce?: "off" | "polite" | "assertive";
+    announcement?: string;
+}
+export interface HysResultContext {
+    status: Exclude<HysResultStatus, number>;
+    code?: HysResultCode;
+    title: string;
+    subtitle?: string;
+}
+export interface HysResultSlots {
+    default?: (context: HysResultContext) => VNodeChild;
+    icon?: (context: HysResultContext) => VNodeChild;
+    title?: (context: HysResultContext) => VNodeChild;
+    subtitle?: (context: HysResultContext) => VNodeChild;
+    extra?: (context: HysResultContext) => VNodeChild;
+}
+export interface HysResultInstance {
+    readonly element: HTMLElement | undefined;
+    focus: (options?: FocusOptions) => void;
+}

package/dist/types/components/HysSpace/HysSpace.vue.d.ts

@@ -0,0 +1,15 @@
+import type { HysSpaceProps, HysSpaceSlots } from "./spaceTypes";
+type __VLS_Slots = HysSpaceSlots;
+declare const __VLS_base: import("vue").DefineComponent<HysSpaceProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<HysSpaceProps> & Readonly<{}>, {
+    size: import("./spaceTypes").HysSpaceGap | readonly [inline: import("./spaceTypes").HysSpaceGap, block: import("./spaceTypes").HysSpaceGap];
+    direction: "horizontal" | "vertical";
+    justify: "center" | "end" | "start" | "evenly" | "around" | "between";
+}, {}, {}, {}, 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/types/components/HysSpace/spaceItems.d.ts

@@ -0,0 +1,9 @@
+import { type VNode } from "vue";
+import type { HysSpaceGap } from "./spaceTypes";
+interface SpaceItem {
+    key: string;
+    node: VNode;
+}
+export declare function collectSpaceItems(nodes: readonly unknown[], path?: string, items?: SpaceItem[]): SpaceItem[];
+export declare function spaceGap(value: HysSpaceGap): string;
+export {};

package/dist/types/components/HysSpace/spaceTypes.d.ts

@@ -0,0 +1,20 @@
+import type { VNode, VNodeChild } from "vue";
+export type HysSpaceGap = number | string;
+export interface HysSpaceProps {
+    direction?: "horizontal" | "vertical";
+    size?: HysSpaceGap | readonly [inline: HysSpaceGap, block: HysSpaceGap];
+    align?: "start" | "center" | "end" | "baseline" | "stretch";
+    justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
+    wrap?: boolean;
+    block?: boolean;
+    fill?: boolean;
+    fillRatio?: number;
+    separator?: string;
+}
+export interface HysSpaceSlots {
+    default?: () => VNode[];
+    separator?: (context: {
+        index: number;
+        count: number;
+    }) => VNodeChild;
+}

package/dist/types/components/HysSpin/HysSpin.vue.d.ts

@@ -0,0 +1,84 @@
+import { type VNodeChild } from "vue";
+import type { HysSpinContext, HysSpinProps, HysSpinRunOptions, HysSpinSnapshot, HysSpinUpdate, HysSpinWork } from "./spinTypes";
+type __VLS_Slots = {
+    default?: () => VNodeChild;
+    indicator?: (context: HysSpinContext) => VNodeChild;
+    icon?: (context: HysSpinContext) => VNodeChild;
+    message?: (context: HysSpinContext) => VNodeChild;
+    progress?: (context: HysSpinContext) => VNodeChild;
+    overlay?: (context: HysSpinContext) => VNodeChild;
+    actions?: (context: HysSpinContext) => VNodeChild;
+};
+declare function show(): void;
+declare function hide(): void;
+declare function update(patch: HysSpinUpdate): void;
+declare function cancel(): void;
+declare function retry(): Promise<unknown> | undefined;
+declare function run<T>(work: HysSpinWork<T>, settings?: HysSpinRunOptions): Promise<T>;
+declare const __VLS_base: import("vue").DefineComponent<HysSpinProps, {
+    show: typeof show;
+    hide: typeof hide;
+    toggle: () => void;
+    run: typeof run;
+    cancel: typeof cancel;
+    retry: typeof retry;
+    update: typeof update;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+    restart: () => void;
+    clearResult: () => void;
+    visible: import("vue").Ref<boolean, boolean>;
+    snapshot: import("vue").ComputedRef<HysSpinSnapshot>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (context: HysSpinSnapshot) => any;
+    "update:modelValue": (spinning: boolean) => any;
+    end: (context: HysSpinSnapshot) => any;
+    success: (context: HysSpinSnapshot) => any;
+    show: (context: HysSpinSnapshot) => any;
+    start: (context: HysSpinSnapshot) => any;
+    cancel: (context: HysSpinSnapshot) => any;
+    error: (error: unknown, context: HysSpinSnapshot) => any;
+    hide: (context: HysSpinSnapshot) => any;
+    retry: (context: HysSpinSnapshot) => any;
+    timeout: (context: HysSpinSnapshot) => any;
+    "update:spinning": (spinning: boolean) => any;
+    afterHide: (context: HysSpinSnapshot) => any;
+}, string, import("vue").PublicProps, Readonly<HysSpinProps> & Readonly<{
+    onChange?: ((context: HysSpinSnapshot) => any) | undefined;
+    "onUpdate:modelValue"?: ((spinning: boolean) => any) | undefined;
+    onEnd?: ((context: HysSpinSnapshot) => any) | undefined;
+    onSuccess?: ((context: HysSpinSnapshot) => any) | undefined;
+    onShow?: ((context: HysSpinSnapshot) => any) | undefined;
+    onStart?: ((context: HysSpinSnapshot) => any) | undefined;
+    onCancel?: ((context: HysSpinSnapshot) => any) | undefined;
+    onError?: ((error: unknown, context: HysSpinSnapshot) => any) | undefined;
+    onHide?: ((context: HysSpinSnapshot) => any) | undefined;
+    onRetry?: ((context: HysSpinSnapshot) => any) | undefined;
+    onTimeout?: ((context: HysSpinSnapshot) => any) | undefined;
+    "onUpdate:spinning"?: ((spinning: boolean) => any) | undefined;
+    onAfterHide?: ((context: HysSpinSnapshot) => any) | undefined;
+}>, {
+    modelValue: boolean;
+    mask: boolean;
+    paused: boolean;
+    pauseWhenHidden: boolean;
+    lockScroll: boolean;
+    spinning: boolean;
+    animated: boolean;
+    defaultSpinning: boolean;
+    showResult: boolean;
+    showPercentage: boolean;
+    blockInteraction: boolean;
+    cancellable: boolean;
+    retryable: boolean;
+    escapeCancel: 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/types/components/HysSpin/SpinGlyph/SpinGlyph.vue.d.ts

@@ -0,0 +1,16 @@
+import type { HysSpinAnimation } from "../spinCatalog";
+import type { HysSpinStatus } from "../spinTypes";
+type __VLS_Props = {
+    animation: HysSpinAnimation;
+    status: HysSpinStatus;
+    progress?: number;
+    stroke: number;
+    dot: number;
+    spacing: number;
+    colors?: readonly string[];
+    gradient?: readonly string[];
+    path?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;