hys-ui 0.5.0 → 0.7.0

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

@@ -0,0 +1,30 @@
+export declare const navigationIcons: {
+    "layout-dashboard": import("../iconTypes").HysIconEntry;
+    "layout-grid": import("../iconTypes").HysIconEntry;
+    "panel-left": import("../iconTypes").HysIconEntry;
+    "panel-right": import("../iconTypes").HysIconEntry;
+    list: import("../iconTypes").HysIconEntry;
+    "list-tree": import("../iconTypes").HysIconEntry;
+    navigation: import("../iconTypes").HysIconEntry;
+    compass: import("../iconTypes").HysIconEntry;
+    bookmark: import("../iconTypes").HysIconEntry;
+    "external-link": import("../iconTypes").HysIconEntry;
+    "log-in": import("../iconTypes").HysIconEntry;
+    "log-out": import("../iconTypes").HysIconEntry;
+    ellipsis: import("../iconTypes").HysIconEntry;
+    "ellipsis-vertical": import("../iconTypes").HysIconEntry;
+};
+export declare const directionsIcons: {
+    "chevron-left": import("../iconTypes").HysIconEntry;
+    "chevron-up": import("../iconTypes").HysIconEntry;
+    "chevrons-left": import("../iconTypes").HysIconEntry;
+    "chevrons-right": import("../iconTypes").HysIconEntry;
+    "chevrons-up": import("../iconTypes").HysIconEntry;
+    "chevrons-down": import("../iconTypes").HysIconEntry;
+    "arrow-up-right": import("../iconTypes").HysIconEntry;
+    "arrow-down-left": import("../iconTypes").HysIconEntry;
+    "arrow-left-right": import("../iconTypes").HysIconEntry;
+    "arrow-up-down": import("../iconTypes").HysIconEntry;
+    "corner-up-left": import("../iconTypes").HysIconEntry;
+    move: import("../iconTypes").HysIconEntry;
+};

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/HysModal/HysModal.vue.d.ts

@@ -92,6 +92,7 @@ declare const __VLS_base: import("vue").DefineComponent<HysModalProps, {
     cancelText: string;
     fullscreen: boolean;
     closeOnEscape: boolean;
+    dragThreshold: number;
     initialFocus: import("../../index.js").HysModalInitialFocus;
     closeOnMask: boolean;
     showClose: boolean;
@@ -113,7 +114,6 @@ declare const __VLS_base: import("vue").DefineComponent<HysModalProps, {
     centered: boolean;
     dragHandlePosition: "left" | "right" | "center" | "both";
     dragMode: "preview" | "live";
-    dragThreshold: number;
     dragEffect: import("../../index.js").HysModalDragEffect;
     keepHandleVisible: boolean;
     resetPositionOnClose: boolean;

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/HysSortableList/HysSortableList.vue.d.ts

@@ -1,29 +1,52 @@
-type Item = {
-    id: string;
-    label: string;
-};
-type __VLS_Props = {
-    modelValue: Item[];
-    disabled?: boolean;
-};
-declare const __VLS_template: () => {
-    __VLS_Slots: {
-        item?: (props: {
-            item: Item;
-        }) => any;
+import { type VNodeChild } from "vue";
+import type { HysSortChange, HysSortDrag, HysSortFeedback, HysSortItem, HysSortKey, HysSortMoveOptions, HysSortPreview, HysSortRow, HysSortableListProps } from "./sortableList";
+declare const __VLS_export: <T extends object = HysSortItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(Omit<HysSortableListProps<T>, "showHandle"> & {
+        showHandle?: boolean;
+    }) & {
+        onChange?: ((change: HysSortChange<T>) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+        onStart?: ((drag: HysSortDrag<T>) => any) | undefined;
+        onCancel?: ((feedback: HysSortFeedback<T>) => any) | undefined;
+        onInvalid?: ((feedback: HysSortFeedback<T>) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((keys: HysSortKey[]) => any) | undefined;
+        onConflict?: ((feedback: HysSortFeedback<T>) => any) | undefined;
+        onPreview?: ((preview: HysSortPreview<T> | null) => any) | undefined;
+        "onSave-error"?: ((feedback: HysSortFeedback<T>) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        move: (keys: HysSortKey | readonly HysSortKey[], options: HysSortMoveOptions) => Promise<boolean>;
+        select: (keys: readonly HysSortKey[]) => void;
+        scrollTo: (key: HysSortKey) => Promise<boolean>;
+        focus: (key: HysSortKey) => Promise<boolean>;
+        undo: () => Promise<boolean>;
+        redo: () => Promise<boolean>;
+        reset: () => Promise<boolean>;
+        cancel: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        item?: (row: HysSortRow<T>) => VNodeChild;
+        handle?: (row: HysSortRow<T>) => VNodeChild;
+        preview?: (context: {
+            drag: HysSortDrag<T>;
+            allowed: boolean;
+        }) => VNodeChild;
+        placeholder?: (row: HysSortRow<T>) => VNodeChild;
+        empty?: () => VNodeChild;
+        header?: () => VNodeChild;
+        cells?: (row: HysSortRow<T>) => VNodeChild;
     };
+    emit: ((evt: "change", change: HysSortChange<T>) => void) & ((evt: "update:modelValue", value: T[]) => void) & ((evt: "start", drag: HysSortDrag<T>) => void) & ((evt: "cancel", feedback: HysSortFeedback<T>) => void) & ((evt: "invalid", feedback: HysSortFeedback<T>) => void) & ((evt: "update:selectedKeys", keys: HysSortKey[]) => void) & ((evt: "conflict", feedback: HysSortFeedback<T>) => void) & ((evt: "preview", preview: HysSortPreview<T> | null) => void) & ((evt: "save-error", feedback: HysSortFeedback<T>) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };
-type __VLS_Slots = ReturnType<typeof __VLS_template>['__VLS_Slots'];
-declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:modelValue": (value: Item[]) => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:modelValue"?: ((value: Item[]) => any) | undefined;
-}>, {}, {}, {}, {}, 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;
-    };
-};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};