@opentiny/tiny-robot 0.4.2-alpha.4 → 0.4.2-alpha.6

package/dist/action-group/ActionGroup.vue.d.ts

@@ -0,0 +1,26 @@
+import { ActionGroupProps, ActionGroupSlots } from './index.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<ActionGroupSlots> & ActionGroupSlots;
+    refs: {
+        moreBtnRef: HTMLSpanElement;
+        dropDownRef: HTMLUListElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<ActionGroupProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "item-click": (name: string) => any;
+}, string, import('vue').PublicProps, Readonly<ActionGroupProps> & Readonly<{
+    "onItem-click"?: ((name: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    moreBtnRef: HTMLSpanElement;
+    dropDownRef: HTMLUListElement;
+}, HTMLDivElement>;
+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/action-group/ActionGroupItem.vue.d.ts

@@ -0,0 +1,18 @@
+import { ActionGroupItemProps } from './index.type';
+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<ActionGroupItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ActionGroupItemProps> & 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/action-group/index.d.ts

@@ -0,0 +1,12 @@
+import { App } from 'vue';
+import { default as ActionGroup } from './ActionGroup.vue';
+import { default as ActionGroupItemComp } from './ActionGroupItem.vue';
+declare const install: <T>(app: App<T>) => void;
+declare const _default: typeof ActionGroup & {
+    install: typeof install;
+};
+export default _default;
+declare const installActionGroupItem: <T>(app: App<T>) => void;
+export declare const ActionGroupItem: typeof ActionGroupItemComp & {
+    install: typeof installActionGroupItem;
+};

package/dist/action-group/index.type.d.ts

@@ -0,0 +1,17 @@
+import { VNode } from 'vue';
+export interface ActionGroupProps {
+    maxNum?: number;
+    showTooltip?: boolean;
+    dropDownShowLabelOnly?: boolean;
+}
+export interface ActionGroupEvents {
+    (e: 'item-click', name: string): void;
+}
+export interface ActionGroupSlots {
+    default: () => VNode | VNode[];
+    moreBtn: () => VNode;
+}
+export interface ActionGroupItemProps {
+    name: string;
+    label: string;
+}

package/dist/anchor/components/AnchorItem.vue.d.ts

@@ -0,0 +1,24 @@
+import { AnchorItemProps, AnchorItemSlots } from '../internal.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AnchorItemSlots> & AnchorItemSlots;
+    refs: {
+        itemButtonRef: HTMLButtonElement;
+    };
+    rootEl: HTMLLIElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AnchorItemProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (item: import('../index.type').AnchorItem) => any;
+}, string, import('vue').PublicProps, Readonly<AnchorItemProps> & Readonly<{
+    onSelect?: ((item: import('../index.type').AnchorItem) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    itemButtonRef: HTMLButtonElement;
+}, HTMLLIElement>;
+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/anchor/components/AnchorList.vue.d.ts

@@ -0,0 +1,20 @@
+import { AnchorListProps, AnchorListSlots } from '../internal.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AnchorListSlots> & AnchorListSlots;
+    refs: {};
+    rootEl: HTMLUListElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AnchorListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (item: import('../index.type').AnchorItem) => any;
+}, string, import('vue').PublicProps, Readonly<AnchorListProps> & Readonly<{
+    onSelect?: ((item: import('../index.type').AnchorItem) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLUListElement>;
+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/anchor/components/AnchorOverlay.vue.d.ts

@@ -0,0 +1,33 @@
+import { AnchorOverlayProps } from '../internal.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        search?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {
+        hostEl: HTMLDivElement;
+        overlayEl: HTMLDivElement;
+        navEl: HTMLElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AnchorOverlayProps, {
+    hostEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    overlayEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    navEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<AnchorOverlayProps> & Readonly<{}>, {
+    floatingOffset: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    hostEl: HTMLDivElement;
+    overlayEl: HTMLDivElement;
+    navEl: HTMLElement;
+}, HTMLDivElement>;
+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/anchor/components/AnchorSearch.vue.d.ts

@@ -0,0 +1,7 @@
+import { AnchorSearchProps } from '../internal.type';
+declare const _default: import('vue').DefineComponent<AnchorSearchProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:searchQuery": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<AnchorSearchProps> & Readonly<{
+    "onUpdate:searchQuery"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLInputElement>;
+export default _default;

package/dist/anchor/composables/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useNavController';
+export * from './useActiveSync';
+export * from './useFloatingOffset';
+export * from './useOverlayInteractions';
+export * from './useTargetFeedback';

package/dist/anchor/composables/useActiveSync.d.ts

@@ -0,0 +1,10 @@
+import { AnchorActiveSyncOptions } from '../internal.type';
+export declare function useActiveSync(options: AnchorActiveSyncOptions): {
+    activeId: import('vue').ComputedRef<string | undefined>;
+    scrollTo: (id: string) => void;
+    sync: () => void;
+    clearPendingScroll: () => void;
+    releaseSelectionLock: () => void;
+    handleUserScrollIntent: () => void;
+    handleScrollIntentKeydown: (event: KeyboardEvent) => void;
+};

package/dist/anchor/composables/useFloatingOffset.d.ts

@@ -0,0 +1,6 @@
+import { AnchorFloatingOffsetOptions } from '../internal.type';
+export declare function useFloatingOffset(options: AnchorFloatingOffsetOptions): {
+    offset: import('vue').Ref<number, number>;
+    sync: () => void;
+    resizeTargets: import('vue').ComputedRef<HTMLElement[]>;
+};

package/dist/anchor/composables/useNavController.d.ts

@@ -0,0 +1,12 @@
+import { AnchorControllerOptions, AnchorFilteredItem } from '../internal.type';
+export declare function useNavController(options: AnchorControllerOptions): {
+    expanded: import('vue').ComputedRef<boolean>;
+    searchQuery: import('vue').ComputedRef<string>;
+    filteredItems: import('vue').ComputedRef<AnchorFilteredItem[]>;
+    highlightedIndex: import('vue').ComputedRef<number>;
+    highlightedId: import('vue').ComputedRef<string>;
+    setExpanded: (value: boolean) => void;
+    setSearchQuery: (value: string) => void;
+    getHighlightedItem: () => import('../index.type').AnchorItem;
+    handleNavigationKeydown: (event: KeyboardEvent) => boolean;
+};

package/dist/anchor/composables/useOverlayInteractions.d.ts

@@ -0,0 +1,6 @@
+import { AnchorOverlayInteractionsOptions } from '../internal.type';
+export declare function useOverlayInteractions(options: AnchorOverlayInteractionsOptions): {
+    handleKeydown: (event: KeyboardEvent) => void;
+    handleMouseLeave: () => void;
+    handleFocusOut: (event: FocusEvent) => void;
+};

package/dist/anchor/composables/useTargetFeedback.d.ts

@@ -0,0 +1,5 @@
+import { AnchorTargetFeedbackOptions } from '../internal.type';
+export declare function useTargetFeedback(options: AnchorTargetFeedbackOptions): {
+    activate: (id: string) => void;
+    clear: () => void;
+};

package/dist/anchor/defaults.d.ts

@@ -0,0 +1,16 @@
+import { AnchorHighlightSegment, AnchorItem, AnchorSearchMatcher } from './index.type';
+export declare const defaultAnchorSearchMatcher: AnchorSearchMatcher;
+export declare function defaultAnchorActiveResolver(options: {
+    viewport: {
+        top: number;
+        scrollTop: number;
+        clientHeight: number;
+        scrollHeight: number;
+    };
+    anchors: Array<{
+        id: string;
+        el: HTMLElement;
+    }>;
+    activeOffset?: number;
+}): string | undefined;
+export declare function ensureAnchorSegments(item: AnchorItem, segments: false | AnchorHighlightSegment[]): AnchorHighlightSegment[];

package/dist/anchor/index.d.ts

@@ -0,0 +1,7 @@
+import { App } from 'vue';
+import { default as Anchor } from './index.vue';
+declare const install: <T>(app: App<T>) => void;
+declare const _default: typeof Anchor & {
+    install: typeof install;
+};
+export default _default;

package/dist/anchor/index.type.d.ts

@@ -0,0 +1,60 @@
+import { VNode } from 'vue';
+export interface AnchorItem {
+    id: string;
+    label: string;
+    searchText?: string;
+    tooltipText?: string;
+    meta?: Record<string, unknown>;
+}
+export interface AnchorHighlightSegment {
+    text: string;
+    highlighted: boolean;
+}
+export type AnchorSearchMatcher = (item: AnchorItem, searchQuery: string) => false | AnchorHighlightSegment[];
+export type AnchorPlacement = 'left' | 'right';
+export type AnchorExpandTrigger = 'hover' | 'manual';
+export interface AnchorSearchOptions {
+    placeholder?: string;
+    matcher?: AnchorSearchMatcher;
+    clearOnCollapse?: boolean;
+}
+export interface AnchorProps {
+    items: AnchorItem[];
+    scrollContainer?: HTMLElement | null;
+    activeId?: string;
+    activeOffset?: number;
+    expanded?: boolean;
+    searchQuery?: string;
+    placement?: AnchorPlacement;
+    expandTrigger?: AnchorExpandTrigger;
+    searchOptions?: AnchorSearchOptions;
+    tooltipDelay?: number;
+    targetFeedbackClass?: string;
+    targetFeedbackDuration?: number;
+    emptyText?: string;
+}
+export interface AnchorEmits {
+    'update:activeId': [value: string | undefined];
+    'update:expanded': [value: boolean];
+    'update:searchQuery': [value: string];
+    select: [item: AnchorItem];
+}
+export interface AnchorSlots {
+    item?: (slotProps: {
+        item: AnchorItem;
+        segments: AnchorHighlightSegment[];
+        active: boolean;
+        expanded: boolean;
+        highlighted: boolean;
+    }) => VNode | VNode[];
+    marker?: (slotProps: {
+        item: AnchorItem;
+        active: boolean;
+    }) => VNode | VNode[];
+    search?: (slotProps: {
+        searchQuery: string;
+        setSearchQuery: (value: string) => void;
+        searchOptions: AnchorSearchOptions;
+    }) => VNode | VNode[];
+    empty?: () => VNode | VNode[];
+}

package/dist/anchor/index.vue.d.ts

@@ -0,0 +1,159 @@
+import { AnchorProps, AnchorSlots } from './index.type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AnchorSlots> & AnchorSlots;
+    refs: {
+        overlayShellRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly expanded: boolean;
+                readonly placement: import('./index.type').AnchorPlacement;
+                readonly floatingOffset?: number | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                hostEl: HTMLDivElement;
+                overlayEl: HTMLDivElement;
+                navEl: HTMLElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./internal.type').AnchorOverlayProps> & Readonly<{}>, {
+                hostEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                overlayEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+                navEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                floatingOffset: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            floatingOffset: number;
+        }> & Omit<Readonly<import('./internal.type').AnchorOverlayProps> & Readonly<{}>, "floatingOffset" | "hostEl" | "overlayEl" | "navEl"> & {
+            hostEl: HTMLElement | null;
+            overlayEl: HTMLElement | null;
+            navEl: HTMLElement | null;
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                search?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<AnchorProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (item: import('./index.type').AnchorItem) => any;
+    "update:searchQuery": (value: string) => any;
+    "update:activeId": (value: string | undefined) => any;
+    "update:expanded": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<AnchorProps> & Readonly<{
+    onSelect?: ((item: import('./index.type').AnchorItem) => any) | undefined;
+    "onUpdate:searchQuery"?: ((value: string) => any) | undefined;
+    "onUpdate:activeId"?: ((value: string | undefined) => any) | undefined;
+    "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
+}>, {
+    placement: import('./index.type').AnchorPlacement;
+    tooltipDelay: number;
+    emptyText: string;
+    activeOffset: number;
+    expandTrigger: import('./index.type').AnchorExpandTrigger;
+    targetFeedbackDuration: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    overlayShellRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly expanded: boolean;
+            readonly placement: import('./index.type').AnchorPlacement;
+            readonly floatingOffset?: number | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            hostEl: HTMLDivElement;
+            overlayEl: HTMLDivElement;
+            navEl: HTMLElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./internal.type').AnchorOverlayProps> & Readonly<{}>, {
+            hostEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            overlayEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            navEl: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            floatingOffset: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        floatingOffset: number;
+    }> & Omit<Readonly<import('./internal.type').AnchorOverlayProps> & Readonly<{}>, "floatingOffset" | "hostEl" | "overlayEl" | "navEl"> & {
+        hostEl: HTMLElement | null;
+        overlayEl: HTMLElement | null;
+        navEl: HTMLElement | null;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            search?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) | null;
+}, 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/anchor/internal.type.d.ts

@@ -0,0 +1,103 @@
+import { Ref } from 'vue';
+import { AnchorExpandTrigger, AnchorHighlightSegment, AnchorItem, AnchorPlacement, AnchorSearchOptions } from './index.type';
+export interface AnchorFilteredItem {
+    item: AnchorItem;
+    segments: AnchorHighlightSegment[];
+}
+export interface AnchorItemSlotProps {
+    item: AnchorItem;
+    segments: AnchorFilteredItem['segments'];
+    active: boolean;
+    expanded: boolean;
+    highlighted: boolean;
+}
+export interface AnchorMarkerSlotProps {
+    item: AnchorItem;
+    active: boolean;
+}
+export interface AnchorSearchProps {
+    searchQuery: string;
+    searchOptions?: AnchorSearchOptions;
+}
+export interface AnchorSearchEmits {
+    'update:searchQuery': [value: string];
+}
+export interface AnchorOverlayProps {
+    expanded: boolean;
+    placement: AnchorPlacement;
+    floatingOffset?: number;
+}
+export interface AnchorOverlayExpose {
+    hostEl: HTMLElement | null;
+    overlayEl: HTMLElement | null;
+    navEl: HTMLElement | null;
+}
+export interface AnchorListProps {
+    items: AnchorFilteredItem[];
+    activeId?: string;
+    expanded: boolean;
+    highlightedIndex: number;
+    placement: AnchorPlacement;
+    tooltipDelay: number;
+    emptyText: string;
+}
+export interface AnchorListEmits {
+    select: [item: AnchorItem];
+}
+export interface AnchorListSlots {
+    item?: (slotProps: AnchorItemSlotProps) => unknown;
+    marker?: (slotProps: AnchorMarkerSlotProps) => unknown;
+    empty?: () => unknown;
+}
+export interface AnchorItemProps {
+    entry: AnchorFilteredItem;
+    activeId?: string;
+    expanded: boolean;
+    highlighted: boolean;
+    placement: AnchorPlacement;
+    tooltipDelay: number;
+}
+export interface AnchorItemEmits {
+    select: [item: AnchorItem];
+}
+export interface AnchorItemSlots {
+    item?: (slotProps: AnchorItemSlotProps) => unknown;
+    marker?: (slotProps: AnchorMarkerSlotProps) => unknown;
+}
+export interface AnchorActiveSyncOptions {
+    items: Ref<AnchorItem[]>;
+    resolveTarget: (id: string) => HTMLElement | null;
+    container: Ref<HTMLElement | null | undefined>;
+    host?: Ref<HTMLElement | null | undefined>;
+    activeId?: Ref<string | undefined>;
+    activeOffset?: Ref<number | undefined>;
+    onUpdateActiveId?: (value: string | undefined) => void;
+}
+export interface AnchorFloatingOffsetOptions {
+    container: Ref<HTMLElement | null | undefined>;
+    host: Ref<HTMLElement | null | undefined>;
+}
+export interface AnchorOverlayInteractionsOptions {
+    overlay: Ref<AnchorOverlayExpose | null>;
+    highlightedId: Ref<string | undefined>;
+    shouldAutoCollapse: Ref<boolean>;
+    handleNavigationKeydown: (event: KeyboardEvent) => boolean;
+    getHighlightedItem: () => AnchorItem | undefined;
+    onSelectItem: (itemId: string) => void;
+    setExpanded: (value: boolean) => void;
+}
+export interface AnchorControllerOptions {
+    items: Ref<AnchorItem[]>;
+    activeId: Ref<string | undefined>;
+    expanded: Ref<boolean | undefined>;
+    expandTrigger: Ref<AnchorExpandTrigger>;
+    searchQuery?: Ref<string | undefined>;
+    searchOptions?: Ref<AnchorSearchOptions | undefined>;
+    onUpdateExpanded?: (value: boolean) => void;
+    onUpdateSearchQuery?: (value: string) => void;
+}
+export interface AnchorTargetFeedbackOptions {
+    resolveTarget: (id: string) => HTMLElement | null;
+    feedbackClass: Ref<string | undefined>;
+    feedbackDuration: Ref<number | undefined>;
+}

package/dist/anchor/utils/scroll.d.ts

@@ -0,0 +1,7 @@
+export type AnchorScrollRoot = HTMLElement | Window;
+export declare function resolveAnchorScrollRoot(container: HTMLElement | null | undefined): AnchorScrollRoot | null;
+export declare function getAnchorScrollTop(root: AnchorScrollRoot | null): number;
+export declare function getAnchorClientHeight(root: AnchorScrollRoot | null): number;
+export declare function getAnchorScrollHeight(root: AnchorScrollRoot | null): number;
+export declare function getAnchorViewportTop(root: AnchorScrollRoot | null): number;
+export declare function scrollAnchorTo(root: AnchorScrollRoot | null, top: number, behavior: ScrollBehavior): void;

package/dist/anchor/utils/target.d.ts

@@ -0,0 +1,6 @@
+export declare const ANCHOR_TARGET_ATTRIBUTE = "data-anchor-id";
+export declare const ANCHOR_TARGET_SELECTOR = "[data-anchor-id]";
+export declare const ANCHOR_ITEM_ATTRIBUTE = "data-item-id";
+export declare const ANCHOR_ITEM_SELECTOR = "[data-item-id]";
+export declare function queryAnchorTargetById(root: ParentNode, id: string): HTMLElement | undefined;
+export declare function queryAnchorItemById(root: ParentNode, id: string): HTMLElement | undefined;

package/dist/attachments/components/FileCard.vue.d.ts

@@ -0,0 +1,18 @@
+import { FileCardProps } from '../index.type';
+declare const _default: import('vue').DefineComponent<FileCardProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    remove: (...args: any[]) => void;
+    download: (...args: any[]) => void;
+    retry: (...args: any[]) => void;
+    preview: (...args: any[]) => void;
+    action: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<FileCardProps> & Readonly<{
+    onRemove?: ((...args: any[]) => any) | undefined;
+    onDownload?: ((...args: any[]) => any) | undefined;
+    onRetry?: ((...args: any[]) => any) | undefined;
+    onPreview?: ((...args: any[]) => any) | undefined;
+    onAction?: ((...args: any[]) => any) | undefined;
+}>, {
+    variant: "picture" | "card";
+    showStatus: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/attachments/components/ImagePreview.vue.d.ts

@@ -0,0 +1,17 @@
+import { Attachment } from '../index.type';
+type Image = Pick<Attachment, 'id' | 'name' | 'url'>;
+interface ImagePreviewProps {
+    images: Image[];
+}
+type __VLS_Props = ImagePreviewProps;
+type __VLS_PublicProps = {
+    'currentIndex': number;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    "update:currentIndex": (value: number) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    "onUpdate:currentIndex"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/attachments/components/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FileCard } from './FileCard.vue';
+export { default as ImagePreview } from './ImagePreview.vue';

package/dist/attachments/composables/index.d.ts

@@ -0,0 +1,5 @@
+import { useFileType } from './useFileType';
+import { useFileCard } from './useFileCard';
+import { useImagePreview } from './useImagePreview';
+import { useListType } from './useListType';
+export { useFileType, useFileCard, useImagePreview, useListType };