halo-pc 1.0.50 → 1.0.51

package/esm/comp/layout/Index.vue.d.ts

@@ -0,0 +1,491 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    DesktopLayout: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
+        appRef: HTMLDivElement;
+        feedbackRef: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+            show: (name: string, url: string) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
+            feedbackRef: {
+                $: import("vue").ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{}> & Omit<{
+                    readonly side?: number;
+                    readonly top?: number;
+                    readonly kind?: string;
+                    readonly type?: string;
+                    readonly name?: string;
+                    readonly title?: string;
+                    readonly index?: number;
+                    readonly focused?: boolean;
+                    readonly class?: string;
+                    readonly options?: import("halo-fe").DialogOptions;
+                    readonly minOptions?: import("halo-fe").DialogOptions;
+                    readonly maxOptions?: import("halo-fe").DialogOptions;
+                    readonly onChange?: (options: import("halo-fe").DialogOptions) => any;
+                    readonly onClose?: (event: MouseEvent) => any;
+                    readonly onFocus?: (value: boolean) => any;
+                    readonly onResize?: (options: import("halo-fe").DialogOptions) => any;
+                    readonly onMax?: (options: import("halo-fe").DialogOptions) => any;
+                    readonly onMin?: (options: import("halo-fe").DialogOptions) => any;
+                    readonly onVisible?: (value: boolean) => any;
+                } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: any;
+                $slots: Readonly<{
+                    [name: string]: import("vue").Slot<any>;
+                }>;
+                $root: import("vue").ComponentPublicInstance | null;
+                $parent: import("vue").ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: ((event: "close", event: MouseEvent) => void) & ((event: "change", options: import("halo-fe").DialogOptions) => void) & ((event: "focus", value: boolean) => void) & ((event: "resize", options: import("halo-fe").DialogOptions) => void) & ((event: "max", options: import("halo-fe").DialogOptions) => void) & ((event: "visible", value: boolean) => void) & ((event: "min", options: import("halo-fe").DialogOptions) => void);
+                $el: any;
+                $options: import("vue").ComponentOptionsBase<Readonly<import("halo-fe/esm/comp/window/@types/WindowProps.js").WindowProps> & Readonly<{
+                    onChange?: (options: import("halo-fe").DialogOptions) => any;
+                    onClose?: (event: MouseEvent) => any;
+                    onFocus?: (value: boolean) => any;
+                    onResize?: (options: import("halo-fe").DialogOptions) => any;
+                    onMax?: (options: import("halo-fe").DialogOptions) => any;
+                    onMin?: (options: import("halo-fe").DialogOptions) => any;
+                    onVisible?: (value: boolean) => any;
+                }>, {
+                    toggle: (value?: boolean) => void;
+                    update: () => void;
+                    state: import("vue").Ref<import("halo-fe").DialogState, import("halo-fe").DialogState>;
+                    visible: import("vue").Ref<boolean, boolean>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    change: (options: import("halo-fe").DialogOptions) => any;
+                    close: (event: MouseEvent) => any;
+                    focus: (value: boolean) => any;
+                    resize: (options: import("halo-fe").DialogOptions) => any;
+                    max: (options: import("halo-fe").DialogOptions) => any;
+                    min: (options: import("halo-fe").DialogOptions) => any;
+                    visible: (value: boolean) => any;
+                }, string, {}, {}, 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<{}> & Omit<Readonly<import("halo-fe/esm/comp/window/@types/WindowProps.js").WindowProps> & Readonly<{
+                onChange?: (options: import("halo-fe").DialogOptions) => any;
+                onClose?: (event: MouseEvent) => any;
+                onFocus?: (value: boolean) => any;
+                onResize?: (options: import("halo-fe").DialogOptions) => any;
+                onMax?: (options: import("halo-fe").DialogOptions) => any;
+                onMin?: (options: import("halo-fe").DialogOptions) => any;
+                onVisible?: (value: boolean) => any;
+            }>, "toggle" | "update" | "visible" | "state"> & import("vue").ShallowUnwrapRef<{
+                toggle: (value?: boolean) => void;
+                update: () => void;
+                state: import("vue").Ref<import("halo-fe").DialogState, import("halo-fe").DialogState>;
+                visible: import("vue").Ref<boolean, boolean>;
+            }> & {} & import("vue").ComponentCustomProperties & {} & {
+                $slots: any;
+            };
+        }, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{}> & Readonly<{}>, {
+            show: (name: string, url: string) => void;
+        }, {}, {}, {}, {}>;
+    }, HTMLDivElement>;
+    SideLayout: import("vue").DefineComponent<{}, {
+        keyboard: (type: import("halo-fe").KeyboardType, event: KeyboardEvent) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+        HeaderIndex: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../header/@types/HeaderProps.js").HeaderProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, HTMLDivElement, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../header/@types/HeaderProps.js").HeaderProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../header/@types/HeaderProps.js").HeaderProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        });
+    }, {}, string, import("vue").ComponentProvideOptions, true, {
+        mainRef: unknown;
+    }, HTMLDivElement>;
+    TopLayout: import("vue").DefineComponent<{}, {
+        keyboard: (type: import("halo-fe").KeyboardType, event: KeyboardEvent) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
+        appRef: HTMLDivElement;
+        menuRef: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            menus: {
+                type: {
+                    (arrayLength: number): any[];
+                    (...items: any[]): any[];
+                    new (arrayLength: number): any[];
+                    new (...items: any[]): any[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                required: true;
+            };
+            direction: {
+                type: StringConstructor;
+                default: string;
+            };
+            expandActive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            options: {
+                type: ObjectConstructor;
+            };
+            modelValue: {
+                type: StringConstructor;
+            };
+        }>> & Readonly<{
+            onClick?: (...args: any[]) => any;
+            "onUpdate:modelValue"?: (...args: any[]) => any;
+        }>, {
+            resize: (event: ResizeObserverEntry) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            click: (...args: any[]) => void;
+            "update:modelValue": (...args: any[]) => void;
+        }, import("vue").PublicProps, {
+            direction: string;
+            expandActive: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
+            menusRef: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                menu: {
+                    type: ObjectConstructor;
+                    required: true;
+                };
+                level: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                direction: {
+                    type: StringConstructor;
+                };
+                opts: {
+                    type: ObjectConstructor;
+                };
+                activeIds: {
+                    type: {
+                        (arrayLength: number): any[];
+                        (...items: any[]): any[];
+                        new (arrayLength: number): any[];
+                        new (...items: any[]): any[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                };
+                modelValue: {
+                    type: StringConstructor;
+                };
+            }>> & Readonly<{
+                onClick?: (...args: any[]) => any;
+            }>, {
+                resize: () => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (...args: any[]) => void;
+            }, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
+                menuRef: HTMLDivElement;
+                scrollerRef: unknown;
+                menusRef: ({
+                    $: import("vue").ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{}> & Omit<{
+                        readonly menu: Record<string, any>;
+                        readonly level: number;
+                        readonly modelValue?: string;
+                        readonly direction?: string;
+                        readonly opts?: Record<string, any>;
+                        readonly activeIds?: any[];
+                        readonly onClick?: (...args: any[]) => any;
+                    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import("vue").Slot<any>;
+                    }>;
+                    $root: import("vue").ComponentPublicInstance | null;
+                    $parent: import("vue").ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: (event: "click", ...args: any[]) => void;
+                    $el: any;
+                    $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                        menu: {
+                            type: ObjectConstructor;
+                            required: true;
+                        };
+                        level: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        direction: {
+                            type: StringConstructor;
+                        };
+                        opts: {
+                            type: ObjectConstructor;
+                        };
+                        activeIds: {
+                            type: {
+                                (arrayLength: number): any[];
+                                (...items: any[]): any[];
+                                new (arrayLength: number): any[];
+                                new (...items: any[]): any[];
+                                isArray(arg: any): arg is any[];
+                                readonly prototype: any[];
+                                from<T>(arrayLike: ArrayLike<T>): T[];
+                                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                                of<T>(...items: T[]): T[];
+                                readonly [Symbol.species]: ArrayConstructor;
+                            };
+                        };
+                        modelValue: {
+                            type: StringConstructor;
+                        };
+                    }>> & Readonly<{
+                        onClick?: (...args: any[]) => any;
+                    }>, {
+                        I18ns: typeof import("../../main.js").I18ns;
+                        menu: import("vue").Ref<Record<string, any>, Record<string, any>>;
+                        level: import("vue").Ref<number, number>;
+                        direction: import("vue").Ref<string, string>;
+                        opts: import("vue").Ref<Record<string, any>, Record<string, any>>;
+                        activeIds: import("vue").Ref<any[], any[]>;
+                        modelValue: import("vue").Ref<string, string>;
+                        menuRef: import("vue").Ref<any, any>;
+                        menusRef: import("vue").Ref<any, any>;
+                        scrollerRef: import("vue").Ref<any, any>;
+                        contentStyle: import("vue").Ref<any, any>;
+                        hovered: import("vue").Ref<boolean, boolean>;
+                        click: (menu: any) => void;
+                        childClick: (menu: any) => void;
+                        mouseOver: (event: MouseEvent) => void;
+                        mouseOut: (event: MouseEvent) => void;
+                        position: import("vue").ComputedRef<string>;
+                        active: import("vue").ComputedRef<boolean>;
+                        anchor: import("vue").ComputedRef<{
+                            href: any;
+                            target: any;
+                        }>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        click: (...args: any[]) => void;
+                    }, string, {}, {}, 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<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{
+                    menu: {
+                        type: ObjectConstructor;
+                        required: true;
+                    };
+                    level: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    direction: {
+                        type: StringConstructor;
+                    };
+                    opts: {
+                        type: ObjectConstructor;
+                    };
+                    activeIds: {
+                        type: {
+                            (arrayLength: number): any[];
+                            (...items: any[]): any[];
+                            new (arrayLength: number): any[];
+                            new (...items: any[]): any[];
+                            isArray(arg: any): arg is any[];
+                            readonly prototype: any[];
+                            from<T>(arrayLike: ArrayLike<T>): T[];
+                            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                            of<T>(...items: T[]): T[];
+                            readonly [Symbol.species]: ArrayConstructor;
+                        };
+                    };
+                    modelValue: {
+                        type: StringConstructor;
+                    };
+                }>> & Readonly<{
+                    onClick?: (...args: any[]) => any;
+                }>, "anchor" | "position" | "click" | "menu" | "I18ns" | "modelValue" | "direction" | "level" | "opts" | "activeIds" | "menuRef" | "menusRef" | "scrollerRef" | "contentStyle" | "hovered" | "childClick" | "mouseOver" | "mouseOut" | "active"> & import("vue").ShallowUnwrapRef<{
+                    I18ns: typeof import("../../main.js").I18ns;
+                    menu: import("vue").Ref<Record<string, any>, Record<string, any>>;
+                    level: import("vue").Ref<number, number>;
+                    direction: import("vue").Ref<string, string>;
+                    opts: import("vue").Ref<Record<string, any>, Record<string, any>>;
+                    activeIds: import("vue").Ref<any[], any[]>;
+                    modelValue: import("vue").Ref<string, string>;
+                    menuRef: import("vue").Ref<any, any>;
+                    menusRef: import("vue").Ref<any, any>;
+                    scrollerRef: import("vue").Ref<any, any>;
+                    contentStyle: import("vue").Ref<any, any>;
+                    hovered: import("vue").Ref<boolean, boolean>;
+                    click: (menu: any) => void;
+                    childClick: (menu: any) => void;
+                    mouseOver: (event: MouseEvent) => void;
+                    mouseOut: (event: MouseEvent) => void;
+                    position: import("vue").ComputedRef<string>;
+                    active: import("vue").ComputedRef<boolean>;
+                    anchor: import("vue").ComputedRef<{
+                        href: any;
+                        target: any;
+                    }>;
+                }> & {} & import("vue").ComponentCustomProperties & {} & {
+                    $slots: {};
+                })[];
+            }, HTMLDivElement, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                menu: {
+                    type: ObjectConstructor;
+                    required: true;
+                };
+                level: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+                direction: {
+                    type: StringConstructor;
+                };
+                opts: {
+                    type: ObjectConstructor;
+                };
+                activeIds: {
+                    type: {
+                        (arrayLength: number): any[];
+                        (...items: any[]): any[];
+                        new (arrayLength: number): any[];
+                        new (...items: any[]): any[];
+                        isArray(arg: any): arg is any[];
+                        readonly prototype: any[];
+                        from<T>(arrayLike: ArrayLike<T>): T[];
+                        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                        of<T>(...items: T[]): T[];
+                        readonly [Symbol.species]: ArrayConstructor;
+                    };
+                };
+                modelValue: {
+                    type: StringConstructor;
+                };
+            }>> & Readonly<{
+                onClick?: (...args: any[]) => any;
+            }>, {
+                resize: () => void;
+            }, {}, {}, {}, {}>[];
+        }, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            menus: {
+                type: {
+                    (arrayLength: number): any[];
+                    (...items: any[]): any[];
+                    new (arrayLength: number): any[];
+                    new (...items: any[]): any[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                required: true;
+            };
+            direction: {
+                type: StringConstructor;
+                default: string;
+            };
+            expandActive: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            options: {
+                type: ObjectConstructor;
+            };
+            modelValue: {
+                type: StringConstructor;
+            };
+        }>> & Readonly<{
+            onClick?: (...args: any[]) => any;
+            "onUpdate:modelValue"?: (...args: any[]) => any;
+        }>, {
+            resize: (event: ResizeObserverEntry) => void;
+        }, {}, {}, {}, {
+            direction: string;
+            expandActive: boolean;
+        }>;
+        mainRef: unknown;
+    }, HTMLDivElement>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/esm/comp/layout/Side.vue.d.ts

@@ -0,0 +1,25 @@
+import { KeyboardType } from "halo-fe";
+declare const _default: import("vue").DefineComponent<{}, {
+    keyboard: (type: KeyboardType, event: KeyboardEvent) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+    HeaderIndex: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../header/@types").HeaderProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, HTMLDivElement, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("../header/@types").HeaderProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("../header/@types").HeaderProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    });
+}, {}, string, import("vue").ComponentProvideOptions, true, {
+    mainRef: unknown;
+}, HTMLDivElement>;
+export default _default;