delta-comic-core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,1112 @@
+export declare const Comp: {
+    Await: <T extends PromiseLike<unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        slots: Readonly<{
+            default(arg: {
+                result: Awaited<T> | undefined;
+                load: () => Promise<T>;
+            }): any;
+        }> & {
+            default(arg: {
+                result: Awaited<T> | undefined;
+                load: () => Promise<T>;
+            }): any;
+        };
+        attrs: any;
+        emit: {};
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            promise: () => T;
+            autoLoad?: boolean;
+        } & import('vue').PublicProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Readonly<{
+            default(arg: {
+                result: Awaited<T> | undefined;
+                load: () => Promise<T>;
+            }): any;
+        }> & {
+            default(arg: {
+                result: Awaited<T> | undefined;
+                load: () => Promise<T>;
+            }): any;
+        };
+        emit: {};
+    }>) => import('vue').VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Loading: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<Partial<import('vant').LoadingProps>> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<Partial<import('vant').LoadingProps>> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<Partial<import('vant').LoadingProps>> & 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;
+        };
+    });
+    Content: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        slots: Readonly<{
+            default(data: {
+                data?: T;
+            }): any;
+        }> & {
+            default(data: {
+                data?: T;
+            }): any;
+        };
+        attrs: any;
+        emit: ((evt: "retry") => void) & ((evt: "resetRetry") => void);
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            readonly onRetry?: () => any;
+            readonly onResetRetry?: () => any;
+            retriable?: boolean;
+            hideError?: boolean;
+            hideEmpty?: boolean;
+            hideLoading?: boolean;
+            source: uData.PromiseContent<any, T[]> | uData.Stream<T> | T[] | T;
+            class?: any;
+            classError?: any;
+            classEmpty?: any;
+            classLoading?: any;
+            style?: import('vue').StyleValue;
+            styleError?: import('vue').StyleValue;
+            styleEmpty?: import('vue').StyleValue;
+            styleLoading?: import('vue').StyleValue;
+        } & import('vue').PublicProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{
+            cont: Readonly<import('vue').ShallowRef<HTMLDivElement>>;
+        }>): void;
+        attrs: any;
+        slots: Readonly<{
+            default(data: {
+                data?: T;
+            }): any;
+        }> & {
+            default(data: {
+                data?: T;
+            }): any;
+        };
+        emit: ((evt: "retry") => void) & ((evt: "resetRetry") => void);
+    }>) => import('vue').VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    FloatPopup: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            anchors?: "high" | "low" | number[];
+            lockScroll?: boolean;
+            class?: any;
+            style?: import('vue').StyleValue;
+            overlay?: boolean;
+        }> & Readonly<{}>, {
+            show(node?: number): void;
+            close(): void;
+            isShowing: Readonly<import('vue').ShallowRef<boolean, boolean>>;
+            height: Readonly<import('vue').ShallowRef<number, number>>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            anchors: "high" | "low" | number[];
+            lockScroll: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            anchors?: "high" | "low" | number[];
+            lockScroll?: boolean;
+            class?: any;
+            style?: import('vue').StyleValue;
+            overlay?: boolean;
+        }> & Readonly<{}>, {
+            show(node?: number): void;
+            close(): void;
+            isShowing: Readonly<import('vue').ShallowRef<boolean, boolean>>;
+            height: Readonly<import('vue').ShallowRef<number, number>>;
+        }, {}, {}, {}, {
+            anchors: "high" | "low" | number[];
+            lockScroll: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<{
+        anchors?: "high" | "low" | number[];
+        lockScroll?: boolean;
+        class?: any;
+        style?: import('vue').StyleValue;
+        overlay?: boolean;
+    }> & Readonly<{}>, {
+        show(node?: number): void;
+        close(): void;
+        isShowing: Readonly<import('vue').ShallowRef<boolean, boolean>>;
+        height: Readonly<import('vue').ShallowRef<number, number>>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        anchors: "high" | "low" | number[];
+        lockScroll: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<{
+            default(arg: {
+                height: number;
+            }): void;
+        }> & {
+            default(arg: {
+                height: number;
+            }): void;
+        };
+    });
+    Image: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            src?: import('./struct/image').Image_;
+            alt?: string;
+            previewable?: boolean;
+            retryMax?: number;
+            round?: boolean;
+            fit?: import('naive-ui').ImageProps["objectFit"];
+            class?: any;
+            hideLoading?: boolean;
+            hideError?: boolean;
+            inline?: boolean;
+            style?: import('vue').StyleValue;
+            imgProp?: import('vue').ImgHTMLAttributes;
+            useList?: {
+                loaded: Set<string>;
+                error: Set<string>;
+            };
+            fetchpriority?: "high" | "low" | "auto";
+            fallback?: import('./struct/image').Image_;
+        }> & Readonly<{
+            onLoad?: (...args: any[]) => any;
+            onClick?: () => any;
+            onError?: () => any;
+        }>, {
+            isLoaded: import('vue').ComputedRef<boolean>;
+            imageEl: any;
+            imageIns: unknown;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            load: (...args: any[]) => any;
+            click: () => any;
+            error: () => any;
+        }, import('vue').PublicProps, {
+            fetchpriority: "high" | "low" | "auto";
+            retryMax: number;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            img: unknown;
+        }, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            src?: import('./struct/image').Image_;
+            alt?: string;
+            previewable?: boolean;
+            retryMax?: number;
+            round?: boolean;
+            fit?: import('naive-ui').ImageProps["objectFit"];
+            class?: any;
+            hideLoading?: boolean;
+            hideError?: boolean;
+            inline?: boolean;
+            style?: import('vue').StyleValue;
+            imgProp?: import('vue').ImgHTMLAttributes;
+            useList?: {
+                loaded: Set<string>;
+                error: Set<string>;
+            };
+            fetchpriority?: "high" | "low" | "auto";
+            fallback?: import('./struct/image').Image_;
+        }> & Readonly<{
+            onLoad?: (...args: any[]) => any;
+            onClick?: () => any;
+            onError?: () => any;
+        }>, {
+            isLoaded: import('vue').ComputedRef<boolean>;
+            imageEl: any;
+            imageIns: unknown;
+        }, {}, {}, {}, {
+            fetchpriority: "high" | "low" | "auto";
+            retryMax: number;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<{
+        src?: import('./struct/image').Image_;
+        alt?: string;
+        previewable?: boolean;
+        retryMax?: number;
+        round?: boolean;
+        fit?: import('naive-ui').ImageProps["objectFit"];
+        class?: any;
+        hideLoading?: boolean;
+        hideError?: boolean;
+        inline?: boolean;
+        style?: import('vue').StyleValue;
+        imgProp?: import('vue').ImgHTMLAttributes;
+        useList?: {
+            loaded: Set<string>;
+            error: Set<string>;
+        };
+        fetchpriority?: "high" | "low" | "auto";
+        fallback?: import('./struct/image').Image_;
+    }> & Readonly<{
+        onLoad?: (...args: any[]) => any;
+        onClick?: () => any;
+        onError?: () => any;
+    }>, {
+        isLoaded: import('vue').ComputedRef<boolean>;
+        imageEl: any;
+        imageIns: unknown;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        load: (...args: any[]) => any;
+        click: () => any;
+        error: () => any;
+    }, string, {
+        fetchpriority: "high" | "low" | "auto";
+        retryMax: number;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<{
+            loading?(): any;
+            fail?(): any;
+        }> & {
+            loading?(): any;
+            fail?(): any;
+        };
+    });
+    List: <T extends NonNullable<import('naive-ui').VirtualListProps["items"]>[number], PF extends ((d: T[]) => any[])>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        slots: Readonly<{
+            default(props: {
+                height: number;
+                data: {
+                    item: import('@vueuse/core').IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                    index: number;
+                };
+            }): any;
+        }> & {
+            default(props: {
+                height: number;
+                data: {
+                    item: import('@vueuse/core').IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                    index: number;
+                };
+            }): any;
+        };
+        attrs: any;
+        emit: ((evt: "retry", then: () => void) => void) & ((evt: "next", then: () => void) => void) & ((evt: "reset") => void);
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            readonly onReset?: () => any;
+            readonly onRetry?: (then: () => void) => any;
+            readonly onNext?: (then: () => void) => any;
+            source: {
+                data: uData.RPromiseContent<any, T[]>;
+                isEnd?: boolean;
+                reloadable?: boolean;
+            } | uData.Stream<T> | Array<T>;
+            itemHeight: number;
+            listProp?: Partial<import('naive-ui').VirtualListProps>;
+            goBottom?: boolean;
+            itemResizable?: boolean;
+            dataProcessor?: PF;
+            style?: import('vue').StyleValue;
+            class?: any;
+        } & import('vue').PublicProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{
+            scrollTop: import('vue').WritableComputedRef<number, number>;
+            listInstance: import('vue').Ref<import('naive-ui').VirtualListInst>;
+        }>): void;
+        attrs: any;
+        slots: Readonly<{
+            default(props: {
+                height: number;
+                data: {
+                    item: import('@vueuse/core').IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                    index: number;
+                };
+            }): any;
+        }> & {
+            default(props: {
+                height: number;
+                data: {
+                    item: import('@vueuse/core').IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                    index: number;
+                };
+            }): any;
+        };
+        emit: ((evt: "retry", then: () => void) => void) & ((evt: "next", then: () => void) => void) & ((evt: "reset") => void);
+    }>) => import('vue').VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Popup: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            show: boolean;
+        } & Partial<{
+            lockScroll: boolean;
+            overlay: boolean;
+            show: boolean;
+            closeable: boolean;
+            closeIcon: string;
+            closeOnPopstate: boolean;
+            closeIconPosition: import('vant').PopupCloseIconPosition;
+            closeOnClickOverlay: boolean;
+            round: boolean;
+            lazyRender: boolean;
+            transitionAppear: boolean;
+            position: import('vant').PopupPosition;
+            destroyOnClose: boolean;
+            safeAreaInsetTop: boolean;
+            safeAreaInsetBottom: boolean;
+        } & {
+            transition?: string;
+            zIndex?: string | number;
+            teleport?: string | import('vue').RendererElement;
+            beforeClose?: import('vant/lib/utils').Interceptor;
+            overlayStyle?: import('vue').CSSProperties;
+            overlayClass?: unknown;
+            duration?: string | number;
+            overlayProps?: Partial<import('vant').OverlayProps>;
+            iconPrefix?: string;
+        } & {
+            noBorder?: boolean;
+            useTrulyShow: boolean;
+            style?: import('vue').StyleValue;
+        }>> & Readonly<{
+            "onUpdate:show"?: (value: boolean) => any;
+            onClosed?: () => any;
+        }>, {
+            zIndex: import('vue').ComputedRef<number>;
+            trulyShow: import('vue').ShallowRef<boolean, boolean>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:show": (value: boolean) => any;
+            closed: () => any;
+        }, import('vue').PublicProps, {
+            position: import('vant').PopupPosition;
+            noBorder: boolean;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            show: boolean;
+        } & Partial<{
+            lockScroll: boolean;
+            overlay: boolean;
+            show: boolean;
+            closeable: boolean;
+            closeIcon: string;
+            closeOnPopstate: boolean;
+            closeIconPosition: import('vant').PopupCloseIconPosition;
+            closeOnClickOverlay: boolean;
+            round: boolean;
+            lazyRender: boolean;
+            transitionAppear: boolean;
+            position: import('vant').PopupPosition;
+            destroyOnClose: boolean;
+            safeAreaInsetTop: boolean;
+            safeAreaInsetBottom: boolean;
+        } & {
+            transition?: string;
+            zIndex?: string | number;
+            teleport?: string | import('vue').RendererElement;
+            beforeClose?: import('vant/lib/utils').Interceptor;
+            overlayStyle?: import('vue').CSSProperties;
+            overlayClass?: unknown;
+            duration?: string | number;
+            overlayProps?: Partial<import('vant').OverlayProps>;
+            iconPrefix?: string;
+        } & {
+            noBorder?: boolean;
+            useTrulyShow: boolean;
+            style?: import('vue').StyleValue;
+        }>> & Readonly<{
+            "onUpdate:show"?: (value: boolean) => any;
+            onClosed?: () => any;
+        }>, {
+            zIndex: import('vue').ComputedRef<number>;
+            trulyShow: import('vue').ShallowRef<boolean, boolean>;
+        }, {}, {}, {}, {
+            position: import('vant').PopupPosition;
+            noBorder: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<{
+        show: boolean;
+    } & Partial<{
+        lockScroll: boolean;
+        overlay: boolean;
+        show: boolean;
+        closeable: boolean;
+        closeIcon: string;
+        closeOnPopstate: boolean;
+        closeIconPosition: import('vant').PopupCloseIconPosition;
+        closeOnClickOverlay: boolean;
+        round: boolean;
+        lazyRender: boolean;
+        transitionAppear: boolean;
+        position: import('vant').PopupPosition;
+        destroyOnClose: boolean;
+        safeAreaInsetTop: boolean;
+        safeAreaInsetBottom: boolean;
+    } & {
+        transition?: string;
+        zIndex?: string | number;
+        teleport?: string | import('vue').RendererElement;
+        beforeClose?: import('vant/lib/utils').Interceptor;
+        overlayStyle?: import('vue').CSSProperties;
+        overlayClass?: unknown;
+        duration?: string | number;
+        overlayProps?: Partial<import('vant').OverlayProps>;
+        iconPrefix?: string;
+    } & {
+        noBorder?: boolean;
+        useTrulyShow: boolean;
+        style?: import('vue').StyleValue;
+    }>> & Readonly<{
+        "onUpdate:show"?: (value: boolean) => any;
+        onClosed?: () => any;
+    }>, {
+        zIndex: import('vue').ComputedRef<number>;
+        trulyShow: import('vue').ShallowRef<boolean, boolean>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:show": (value: boolean) => any;
+        closed: () => any;
+    }, string, {
+        position: import('vant').PopupPosition;
+        noBorder: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: Readonly<{
+            default(): void;
+        }> & {
+            default(): void;
+        };
+    });
+    RouterTab: <T extends {
+        name: string;
+        title: string;
+        queries?: Record<string, string>;
+    }>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        slots: Readonly<{
+            default(arg: {
+                itemName: T;
+            }): any;
+            left(): any;
+            right(): any;
+            bottom(): any;
+        }> & {
+            default(arg: {
+                itemName: T;
+            }): any;
+            left(): any;
+            right(): any;
+            bottom(): any;
+        };
+        attrs: any;
+        emit: {};
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            items: T[];
+            routerBase: string;
+        } & import('vue').PublicProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Readonly<{
+            default(arg: {
+                itemName: T;
+            }): any;
+            left(): any;
+            right(): any;
+            bottom(): any;
+        }> & {
+            default(arg: {
+                itemName: T;
+            }): any;
+            left(): any;
+            right(): any;
+            bottom(): any;
+        };
+        emit: {};
+    }>) => import('vue').VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Text: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            text?: string;
+            ellipsis?: number;
+        }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            text: string;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            text?: string;
+            ellipsis?: number;
+        }> & Readonly<{}>, {}, {}, {}, {}, {
+            text: string;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<{
+        text?: string;
+        ellipsis?: number;
+    }> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+        text: 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;
+        };
+    });
+    ToggleIcon: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            modelValue?: boolean;
+        } & {
+            icon: import('vue').Component;
+            size?: string | number;
+            disChanged?: boolean;
+            rowMode?: boolean;
+            padding?: boolean;
+        }> & Readonly<{
+            onClick?: (to: boolean) => any;
+            "onUpdate:modelValue"?: (value: boolean) => any;
+            onChange?: (mode: boolean) => any;
+            onLongClick?: () => any;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            click: (to: boolean) => any;
+            "update:modelValue": (value: boolean) => any;
+            change: (mode: boolean) => any;
+            longClick: () => any;
+        }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            htmlRefHook: HTMLDivElement;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            modelValue?: boolean;
+        } & {
+            icon: import('vue').Component;
+            size?: string | number;
+            disChanged?: boolean;
+            rowMode?: boolean;
+            padding?: boolean;
+        }> & Readonly<{
+            onClick?: (to: boolean) => any;
+            "onUpdate:modelValue"?: (value: boolean) => any;
+            onChange?: (mode: boolean) => any;
+            onLongClick?: () => any;
+        }>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<{
+        modelValue?: boolean;
+    } & {
+        icon: import('vue').Component;
+        size?: string | number;
+        disChanged?: boolean;
+        rowMode?: boolean;
+        padding?: boolean;
+    }> & Readonly<{
+        onClick?: (to: boolean) => any;
+        "onUpdate:modelValue"?: (value: boolean) => any;
+        onChange?: (mode: boolean) => any;
+        onLongClick?: () => any;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        click: (to: boolean) => any;
+        "update:modelValue": (value: boolean) => any;
+        change: (mode: boolean) => any;
+        longClick: () => any;
+    }, 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;
+        };
+    });
+    Var: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        slots: Readonly<{
+            default(arg: {
+                value: T;
+            }): any;
+        }> & {
+            default(arg: {
+                value: T;
+            }): any;
+        };
+        attrs: any;
+        emit: {};
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            value: T;
+        } & import('vue').PublicProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: Readonly<{
+            default(arg: {
+                value: T;
+            }): any;
+        }> & {
+            default(arg: {
+                value: T;
+            }): any;
+        };
+        emit: {};
+    }>) => import('vue').VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Waterfall: <T = any, PF extends ((d: T[]) => any[]) = (d: T[]) => T[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        slots: Readonly<{
+            default(props: {
+                item: import('@vueuse/core').IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                index: number;
+                height?: number;
+                minHeight: number;
+                length: number;
+            }): any;
+        }> & {
+            default(props: {
+                item: import('@vueuse/core').IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                index: number;
+                height?: number;
+                minHeight: number;
+                length: number;
+            }): any;
+        };
+        attrs: any;
+        emit: ((evt: "retry", then: () => void) => void) & ((evt: "next", then: () => void) => void) & ((evt: "reset") => void) & ((evt: "col", args_0: 2, args_1: 2) => void);
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            readonly onReset?: () => any;
+            readonly onRetry?: (then: () => void) => any;
+            readonly onNext?: (then: () => void) => any;
+            readonly onCol?: (args_0: 2, args_1: 2) => any;
+            source: {
+                data: uData.RPromiseContent<any, T[]>;
+                isEnd?: boolean;
+            } | uData.Stream<T>;
+            style?: import('vue').StyleValue;
+            class?: any;
+            col?: [min: number, max: number] | number;
+            padding?: number;
+            gap?: number;
+            minHeight?: number;
+            dataProcessor?: PF;
+            unReloadable?: boolean;
+        } & import('vue').PublicProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{
+            scrollTop: import('vue').WritableComputedRef<number, number>;
+            scrollParent: import('vue').ComputedRef<HTMLDivElement>;
+            reloadList(): Promise<void>;
+        }>): void;
+        attrs: any;
+        slots: Readonly<{
+            default(props: {
+                item: import('@vueuse/core').IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                index: number;
+                height?: number;
+                minHeight: number;
+                length: number;
+            }): any;
+        }> & {
+            default(props: {
+                item: import('@vueuse/core').IfAny<ReturnType<PF>[number], T, ReturnType<PF>[number]>;
+                index: number;
+                height?: number;
+                minHeight: number;
+                length: number;
+            }): any;
+        };
+        emit: ((evt: "retry", then: () => void) => void) & ((evt: "next", then: () => void) => void) & ((evt: "reset") => void) & ((evt: "col", args_0: 2, args_1: 2) => void);
+    }>) => import('vue').VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    user: {
+        PreviewUser: import('vue').DefineComponent<{}, {
+            show(u: any): void;
+            isShowing: import('vue').ComputedRef<boolean>;
+            close(): void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+            floatPopup: {
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    anchors: "high" | "low" | number[];
+                    lockScroll: boolean;
+                }> & Omit<{
+                    readonly anchors?: "high" | "low" | number[];
+                    readonly lockScroll?: boolean;
+                    readonly class?: any;
+                    readonly style?: import('vue').StyleValue;
+                    readonly overlay?: boolean;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "anchors" | "lockScroll">;
+                $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: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<{
+                    anchors?: "high" | "low" | number[];
+                    lockScroll?: boolean;
+                    class?: any;
+                    style?: import('vue').StyleValue;
+                    overlay?: boolean;
+                }> & Readonly<{}>, {
+                    show(node?: number): void;
+                    close(): void;
+                    isShowing: Readonly<import('vue').ShallowRef<boolean, boolean>>;
+                    height: Readonly<import('vue').ShallowRef<number, number>>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    anchors: "high" | "low" | number[];
+                    lockScroll: boolean;
+                }, {}, 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<{
+                anchors: "high" | "low" | number[];
+                lockScroll: boolean;
+            }> & Omit<Readonly<{
+                anchors?: "high" | "low" | number[];
+                lockScroll?: boolean;
+                class?: any;
+                style?: import('vue').StyleValue;
+                overlay?: boolean;
+            }> & Readonly<{}>, "height" | "show" | ("anchors" | "lockScroll") | "close" | "isShowing"> & import('vue').ShallowUnwrapRef<{
+                show(node?: number): void;
+                close(): void;
+                isShowing: Readonly<import('vue').ShallowRef<boolean, boolean>>;
+                height: Readonly<import('vue').ShallowRef<number, number>>;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: Readonly<{
+                    default(arg: {
+                        height: number;
+                    }): void;
+                }> & {
+                    default(arg: {
+                        height: number;
+                    }): void;
+                };
+            };
+            contentBox: HTMLDivElement;
+        }, any>;
+    };
+    content: {
+        UnitCard: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+                item: import('./struct/item').Item | import('./struct/item').RawItem;
+                freeHeight?: boolean;
+                disabled?: boolean;
+                type?: "default" | "big" | "small";
+                class?: any;
+                style?: import('vue').StyleValue;
+            }> & Readonly<{
+                onClick?: () => any;
+            }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: () => any;
+            }, import('vue').PublicProps, {
+                type: "default" | "big" | "small";
+            }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                container: HTMLDivElement;
+                cover: {
+                    $: import('vue').ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        fetchpriority: "high" | "low" | "auto";
+                        retryMax: number;
+                    }> & Omit<{
+                        readonly src?: import('./struct/image').Image_;
+                        readonly alt?: string;
+                        readonly previewable?: boolean;
+                        readonly retryMax?: number;
+                        readonly round?: boolean;
+                        readonly fit?: import('naive-ui').ImageProps["objectFit"];
+                        readonly class?: any;
+                        readonly hideLoading?: boolean;
+                        readonly hideError?: boolean;
+                        readonly inline?: boolean;
+                        readonly style?: import('vue').StyleValue;
+                        readonly imgProp?: import('vue').ImgHTMLAttributes;
+                        readonly useList?: {
+                            loaded: Set<string>;
+                            error: Set<string>;
+                        };
+                        readonly fetchpriority?: "high" | "low" | "auto";
+                        readonly fallback?: import('./struct/image').Image_;
+                        readonly onLoad?: (...args: any[]) => any;
+                        readonly onClick?: () => any;
+                        readonly onError?: () => any;
+                    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "fetchpriority" | "retryMax">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    } & {
+                        img: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import('vue').Slot<any>;
+                    }>;
+                    $root: import('vue').ComponentPublicInstance | null;
+                    $parent: import('vue').ComponentPublicInstance | null;
+                    $host: Element | null;
+                    $emit: ((event: "load", ...args: any[]) => void) & ((event: "click") => void) & ((event: "error") => void);
+                    $el: any;
+                    $options: import('vue').ComponentOptionsBase<Readonly<{
+                        src?: import('./struct/image').Image_;
+                        alt?: string;
+                        previewable?: boolean;
+                        retryMax?: number;
+                        round?: boolean;
+                        fit?: import('naive-ui').ImageProps["objectFit"];
+                        class?: any;
+                        hideLoading?: boolean;
+                        hideError?: boolean;
+                        inline?: boolean;
+                        style?: import('vue').StyleValue;
+                        imgProp?: import('vue').ImgHTMLAttributes;
+                        useList?: {
+                            loaded: Set<string>;
+                            error: Set<string>;
+                        };
+                        fetchpriority?: "high" | "low" | "auto";
+                        fallback?: import('./struct/image').Image_;
+                    }> & Readonly<{
+                        onLoad?: (...args: any[]) => any;
+                        onClick?: () => any;
+                        onError?: () => any;
+                    }>, {
+                        isLoaded: import('vue').ComputedRef<boolean>;
+                        imageEl: any;
+                        imageIns: unknown;
+                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                        load: (...args: any[]) => any;
+                        click: () => any;
+                        error: () => any;
+                    }, string, {
+                        fetchpriority: "high" | "low" | "auto";
+                        retryMax: 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<{
+                    fetchpriority: "high" | "low" | "auto";
+                    retryMax: number;
+                }> & Omit<Readonly<{
+                    src?: import('./struct/image').Image_;
+                    alt?: string;
+                    previewable?: boolean;
+                    retryMax?: number;
+                    round?: boolean;
+                    fit?: import('naive-ui').ImageProps["objectFit"];
+                    class?: any;
+                    hideLoading?: boolean;
+                    hideError?: boolean;
+                    inline?: boolean;
+                    style?: import('vue').StyleValue;
+                    imgProp?: import('vue').ImgHTMLAttributes;
+                    useList?: {
+                        loaded: Set<string>;
+                        error: Set<string>;
+                    };
+                    fetchpriority?: "high" | "low" | "auto";
+                    fallback?: import('./struct/image').Image_;
+                }> & Readonly<{
+                    onLoad?: (...args: any[]) => any;
+                    onClick?: () => any;
+                    onError?: () => any;
+                }>, ("fetchpriority" | "retryMax") | "isLoaded" | "imageEl" | "imageIns"> & import('vue').ShallowUnwrapRef<{
+                    isLoaded: import('vue').ComputedRef<boolean>;
+                    imageEl: any;
+                    imageIns: unknown;
+                }> & {} & import('vue').ComponentCustomProperties & {} & {
+                    $slots: Readonly<{
+                        loading?(): any;
+                        fail?(): any;
+                    }> & {
+                        loading?(): any;
+                        fail?(): any;
+                    };
+                };
+            }, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{
+                item: import('./struct/item').Item | import('./struct/item').RawItem;
+                freeHeight?: boolean;
+                disabled?: boolean;
+                type?: "default" | "big" | "small";
+                class?: any;
+                style?: import('vue').StyleValue;
+            }> & Readonly<{
+                onClick?: () => any;
+            }>, {}, {}, {}, {}, {
+                type: "default" | "big" | "small";
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<{
+            item: import('./struct/item').Item | import('./struct/item').RawItem;
+            freeHeight?: boolean;
+            disabled?: boolean;
+            type?: "default" | "big" | "small";
+            class?: any;
+            style?: import('vue').StyleValue;
+        }> & Readonly<{
+            onClick?: () => any;
+        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            click: () => any;
+        }, string, {
+            type: "default" | "big" | "small";
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: Readonly<{
+                default(): void;
+                smallTopInfo(): void;
+            }> & {
+                default(): void;
+                smallTopInfo(): void;
+            };
+        });
+    };
+};
+export { uni } from './struct/index';
+import * as uData from './utils/data';
+import * as uDelay from './utils/delay';
+import * as uEventBus from './utils/eventBus';
+import * as uImage from './utils/image';
+import * as uLayout from './utils/layout';
+import * as uRequest from './utils/request';
+import * as uTranslate from './utils/translate';
+import * as uMessage from './utils/message';
+export declare namespace Utils {
+    export import data = uData;
+    export import delay = uDelay;
+    export import eventBus = uEventBus;
+    export import image = uImage;
+    export import layout = uLayout;
+    export import request = uRequest;
+    export import translate = uTranslate;
+    export import message = uMessage;
+}
+export declare const Store: {
+    useTemp: import('pinia').StoreDefinition<"core:temp", Pick<{
+        $apply: <T extends object>(id: string, def: () => T) => import('vue').Reactive<T>;
+        $has: (id: string) => boolean;
+        $onlyGet: <T extends object>(id: string) => import('vue').Reactive<T>;
+        $applyRaw: <T extends object>(id: string, def: () => T) => T;
+        $hasRaw: (id: string) => boolean;
+        $onlyGetRaw: <T extends object>(id: string) => import('vue').Reactive<T>;
+    }, never>, Pick<{
+        $apply: <T extends object>(id: string, def: () => T) => import('vue').Reactive<T>;
+        $has: (id: string) => boolean;
+        $onlyGet: <T extends object>(id: string) => import('vue').Reactive<T>;
+        $applyRaw: <T extends object>(id: string, def: () => T) => T;
+        $hasRaw: (id: string) => boolean;
+        $onlyGetRaw: <T extends object>(id: string) => import('vue').Reactive<T>;
+    }, never>, Pick<{
+        $apply: <T extends object>(id: string, def: () => T) => import('vue').Reactive<T>;
+        $has: (id: string) => boolean;
+        $onlyGet: <T extends object>(id: string) => import('vue').Reactive<T>;
+        $applyRaw: <T extends object>(id: string, def: () => T) => T;
+        $hasRaw: (id: string) => boolean;
+        $onlyGetRaw: <T extends object>(id: string) => import('vue').Reactive<T>;
+    }, "$apply" | "$has" | "$onlyGet" | "$applyRaw" | "$hasRaw" | "$onlyGetRaw">>;
+    useConfig: import('pinia').StoreDefinition<"config", Pick<{
+        isDark: import('vue').ComputedRef<boolean>;
+        $useCustomConfig: <T extends Record<string, any>>(plugin: string, defaultConfig: T) => T;
+        'app.read.preloadImageNumbers': number;
+        'app.read.watchFullscreen': boolean;
+        'app.read.twoImage': boolean;
+        'app.search.showAIProject': boolean;
+        'app.darkMode': boolean;
+        "app.recordHistory": boolean;
+    }, "app.read.preloadImageNumbers" | "app.read.watchFullscreen" | "app.read.twoImage" | "app.search.showAIProject" | "app.darkMode" | "app.recordHistory">, Pick<{
+        isDark: import('vue').ComputedRef<boolean>;
+        $useCustomConfig: <T extends Record<string, any>>(plugin: string, defaultConfig: T) => T;
+        'app.read.preloadImageNumbers': number;
+        'app.read.watchFullscreen': boolean;
+        'app.read.twoImage': boolean;
+        'app.search.showAIProject': boolean;
+        'app.darkMode': boolean;
+        "app.recordHistory": boolean;
+    }, "isDark">, Pick<{
+        isDark: import('vue').ComputedRef<boolean>;
+        $useCustomConfig: <T extends Record<string, any>>(plugin: string, defaultConfig: T) => T;
+        'app.read.preloadImageNumbers': number;
+        'app.read.watchFullscreen': boolean;
+        'app.read.twoImage': boolean;
+        'app.search.showAIProject': boolean;
+        'app.darkMode': boolean;
+        "app.recordHistory": boolean;
+    }, "$useCustomConfig">>;
+};
+export * from './plugin';