@zjhc/ui 0.0.0-stage → 0.1.0

package/dist/components/dialog/src/dialogContent.vue.d.ts

@@ -0,0 +1,74 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        default?(_: {}): any;
+        footer?(_: {}): any;
+    };
+    refs: {
+        headerRef: HTMLElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly center: BooleanConstructor;
+    readonly alignCenter: BooleanConstructor;
+    readonly closeIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<import('vue').PropType<string | import('vue').Component>, unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly draggable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly resizable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly overflow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly showClose: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+}>, {
+    resetPosition: () => void;
+    resetSize: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+    minusChange: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly center: BooleanConstructor;
+    readonly alignCenter: BooleanConstructor;
+    readonly closeIcon: {
+        readonly type: import('vue').PropType<import('element-plus/es/utils/index').EpPropMergeType<import('vue').PropType<string | import('vue').Component>, unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly draggable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly resizable: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly overflow: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly fullscreen: BooleanConstructor;
+    readonly showClose: import('element-plus/es/utils/index').EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly title: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly ariaLevel: import('element-plus/es/utils/index').EpPropFinalized<StringConstructor, unknown, unknown, "2", boolean>;
+}>> & Readonly<{
+    onClose?: (...args: any[]) => any;
+    onMinusChange?: (...args: any[]) => any;
+}>, {
+    readonly overflow: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly title: string;
+    readonly center: boolean;
+    readonly resizable: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly draggable: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showClose: import('element-plus/es/utils/index').EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly ariaLevel: string;
+    readonly alignCenter: boolean;
+    readonly fullscreen: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    headerRef: 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/components/dialog/src/use-dialog.d.ts

@@ -0,0 +1,23 @@
+import { CSSProperties, Ref } from 'vue';
+import { DialogProps } from './dialog';
+export declare const useDialog: (props: DialogProps, targetRef: Ref<HTMLElement | undefined>) => {
+    afterEnter: () => void;
+    afterLeave: () => void;
+    beforeLeave: () => void;
+    handleClose: () => void;
+    onModalClick: () => void;
+    close: () => void;
+    doClose: () => void;
+    onOpenAutoFocus: () => void;
+    onCloseAutoFocus: () => void;
+    onCloseRequested: () => void;
+    onFocusoutPrevented: (event: CustomEvent) => void;
+    titleId: Ref<string, string>;
+    bodyId: Ref<string, string>;
+    closed: Ref<boolean, boolean>;
+    style: import('vue').ComputedRef<CSSProperties>;
+    overlayDialogStyle: import('vue').ComputedRef<CSSProperties>;
+    rendered: Ref<boolean, boolean>;
+    visible: Ref<boolean, boolean>;
+    zIndex: Ref<number, number>;
+};

package/dist/components/edit-table-column/EditTableColumn.vue.d.ts

@@ -0,0 +1,79 @@
+import { PropType } from 'vue';
+import { SelectOptions } from './type';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        append?(_: any): any;
+        append?(_: {}): any;
+        default?(_: any): any;
+        prepend?(_: {}): any;
+        filterIcon?(_: any): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    inputName: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    inputProps: {
+        type: PropType<Record<string, unknown>>;
+        required: false;
+        default: () => {};
+    };
+    inputChild: {
+        type: PropType<unknown[]>;
+        required: false;
+    };
+    isEdit: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+    selectOptions: {
+        type: PropType<SelectOptions[]>;
+        required: false;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "on-change": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    inputName: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    inputProps: {
+        type: PropType<Record<string, unknown>>;
+        required: false;
+        default: () => {};
+    };
+    inputChild: {
+        type: PropType<unknown[]>;
+        required: false;
+    };
+    isEdit: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+    selectOptions: {
+        type: PropType<SelectOptions[]>;
+        required: false;
+    };
+}>> & Readonly<{
+    "onOn-change"?: (...args: any[]) => any;
+}>, {
+    inputName: string;
+    inputProps: Record<string, unknown>;
+    isEdit: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/components/edit-table-column/index.d.ts

@@ -0,0 +1,6 @@
+import { default as EditTableColumn } from './EditTableColumn.vue';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcEditTableColumn: SFCWithInstall<typeof EditTableColumn>;
+export { registerComp } from './registerComp';
+export * from './type';
+export default EditTableColumn;

package/dist/components/edit-table-column/registerComp.d.ts

@@ -0,0 +1,3 @@
+import { Component } from 'vue';
+export declare function getComp(name: string): Component;
+export declare function registerComp(name: string, comp: Component): void;

package/dist/components/edit-table-column/type.d.ts

@@ -0,0 +1,14 @@
+import { TableColumnCtx } from 'element-plus';
+import { VNode } from 'vue';
+export interface SelectOptions {
+    value: string | number | boolean | object;
+    label: string | number;
+    disabled?: boolean;
+}
+export interface EditTableColumnProps<T = object> extends Omit<TableColumnCtx<T>, 'children'> {
+    inputName: string;
+    inputProps: object;
+    inputChild: VNode[];
+    isEdit: boolean;
+    selectOptions: SelectOptions[];
+}

package/dist/components/group-container/index.d.ts

@@ -0,0 +1,6 @@
+import { default as GroupContainer } from './src/groupContainer.vue';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcGroupContainer: SFCWithInstall<typeof GroupContainer>;
+export default ZjhcGroupContainer;
+export * from './src/groupContainer.vue';
+export type { GroupContainerInstance } from './src/instance';

package/dist/components/group-container/src/groupContainer.vue.d.ts

@@ -0,0 +1,43 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        toolbar?(_: {}): any;
+        content?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    isBorder: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    isBorder: {
+        type: BooleanConstructor;
+        required: false;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    title: string;
+    isBorder: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/components/group-container/src/instance.d.ts

@@ -0,0 +1,2 @@
+import { default as GroupContainer } from './groupContainer.vue';
+export type GroupContainerInstance = InstanceType<typeof GroupContainer>;

package/dist/components/index.d.ts

@@ -0,0 +1,13 @@
+export * from './search-panel';
+export * from './search-panel-layout';
+export * from './search-layout';
+export * from './collapse-panel';
+export * from './collapse-container';
+export * from './sticky-toolbar';
+export * from './group-container';
+export * from './table-toolbar';
+export * from './dialog';
+export * from './complex-table';
+export * from './autocomplete';
+export * from './loading';
+export * from './edit-table-column';

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

@@ -0,0 +1,11 @@
+import { Loading } from './src/service';
+import { vLoading as vZjhcLoading } from './src/directive';
+import { App } from 'vue';
+export declare const ZjhcLoading: {
+    install(app: App): void;
+    directive: import('vue').Directive<import('./src/directive').ElementLoading, import('./src/directive').LoadingBinding>;
+    service: (options?: import('.').LoadingOptions) => import('./src/loading').LoadingInstance;
+};
+export default ZjhcLoading;
+export { vZjhcLoading, vZjhcLoading as ZjhcLoadingDirective, Loading as ZjhcLoadingService, };
+export * from './src/types';

package/dist/components/loading/src/directive.d.ts

@@ -0,0 +1,13 @@
+import { Directive, UnwrapRef } from 'vue';
+import { LoadingOptions } from './types';
+import { LoadingInstance } from './loading';
+declare const INSTANCE_KEY: unique symbol;
+export type LoadingBinding = boolean | UnwrapRef<LoadingOptions>;
+export interface ElementLoading extends HTMLElement {
+    [INSTANCE_KEY]?: {
+        instance: LoadingInstance;
+        options: LoadingOptions;
+    };
+}
+export declare const vLoading: Directive<ElementLoading, LoadingBinding>;
+export {};

package/dist/components/loading/src/loading.d.ts

@@ -0,0 +1,27 @@
+import { LoadingOptionsResolved } from './types';
+export declare function createLoadingComponent(options: LoadingOptionsResolved): {
+    setText: (text: string) => void;
+    removeElLoadingChild: () => void;
+    close: () => void;
+    handleAfterLeave: () => void;
+    vm: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any>;
+    $el: HTMLElement;
+    originalPosition: import('vue').Ref<string, string>;
+    originalOverflow: import('vue').Ref<string, string>;
+    visible: import('vue').Ref<boolean, boolean>;
+    parent: import('vue').Ref<import('./types').LoadingParentElement, import('./types').LoadingParentElement>;
+    fillColor: import('vue').Ref<string, string>;
+    animateColor: import('vue').Ref<string, string>;
+    background: import('vue').Ref<string, string>;
+    svg: import('vue').Ref<string, string>;
+    svgViewBox: import('vue').Ref<string, string>;
+    spinner: import('vue').Ref<string | boolean, string | boolean>;
+    text: import('vue').Ref<string, string>;
+    fullscreen: import('vue').Ref<boolean, boolean>;
+    lock: import('vue').Ref<boolean, boolean>;
+    customClass: import('vue').Ref<string, string>;
+    target: import('vue').Ref<HTMLElement, HTMLElement>;
+    beforeClose?: import('vue').Ref<() => boolean, () => boolean>;
+    closed?: import('vue').Ref<() => void, () => void>;
+};
+export type LoadingInstance = ReturnType<typeof createLoadingComponent>;

package/dist/components/loading/src/service.d.ts

@@ -0,0 +1,3 @@
+import { LoadingInstance } from './loading';
+import { LoadingOptions } from './types';
+export declare const Loading: (options?: LoadingOptions) => LoadingInstance;

package/dist/components/loading/src/types.d.ts

@@ -0,0 +1,61 @@
+import { MaybeRef } from '@vueuse/core';
+export type LoadingOptionsResolved = {
+    parent: LoadingParentElement;
+    /**
+     * 图标填充色
+     */
+    fillColor: MaybeRef<string>;
+    /**
+     * 图标动画填充色
+     */
+    animateColor: MaybeRef<string>;
+    /**
+     * 遮罩背景色
+     */
+    background: MaybeRef<string>;
+    /**
+     * 自定义 SVG 元素覆盖默认加载器
+     */
+    svg: MaybeRef<string>;
+    /**
+     * 设置用于加载 svg 元素的 viewBox 属性
+     */
+    svgViewBox: MaybeRef<string>;
+    /**
+     * 自定义加载图标类名
+     */
+    spinner: MaybeRef<boolean | string>;
+    /**
+     * 显示在加载图标下方的加载文案
+     */
+    text: MaybeRef<string>;
+    /**
+     * 同 v-zjhcloading 指令中的 fullscreen 修饰符
+     */
+    fullscreen: boolean;
+    /**
+     * 同 v-zjhcloading 指令中的 lock 修饰符
+     */
+    lock: boolean;
+    /**
+     * 	Loading 的自定义类名
+     */
+    customClass: MaybeRef<string>;
+    visible: boolean;
+    target: HTMLElement;
+    beforeClose?: () => boolean;
+    closed?: () => void;
+};
+export type LoadingOptions = Partial<Omit<LoadingOptionsResolved, 'parent' | 'target'> & {
+    /**
+     * @description the DOM node Loading needs to cover. Accepts a DOM object or a string. If it's a string, it will be passed to `document.querySelector` to get the corresponding DOM node
+     */
+    target: HTMLElement | string;
+    /**
+     * @description same as the `body` modifier of `v-zjhcloading`
+     */
+    body: boolean;
+}>;
+export interface LoadingParentElement extends HTMLElement {
+    vLoadingAddClassList?: () => void;
+}

package/dist/components/search-layout/index.d.ts

@@ -0,0 +1,6 @@
+import { default as SearchLayout } from './src/searchLayout.vue';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcSearchLayout: SFCWithInstall<typeof SearchLayout>;
+export default ZjhcSearchLayout;
+export * from './src/searchLayout.vue';
+export type { SearchLayoutInstance } from './src/instance';

package/dist/components/search-layout/src/instance.d.ts

@@ -0,0 +1,2 @@
+import { default as SearchLayout } from './searchLayout.vue';
+export type SearchLayoutInstance = InstanceType<typeof SearchLayout>;

package/dist/components/search-layout/src/searchLayout.vue.d.ts

@@ -0,0 +1,22 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        search?(_: {}): any;
+        sidebar?(_: {}): any;
+        toolbar?(_: {}): any;
+        list?(_: {}): any;
+        pagination?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/components/search-panel/index.d.ts

@@ -0,0 +1,6 @@
+import { default as SearchPanel } from './src/searchPanel.vue';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcSearchPanel: SFCWithInstall<typeof SearchPanel>;
+export default ZjhcSearchPanel;
+export * from './src/searchPanel.vue';
+export type { SearchPanelInstance } from './src/instance';

package/dist/components/search-panel/src/instance.d.ts

@@ -0,0 +1,2 @@
+import { default as SearchPanel } from './searchPanel.vue';
+export type SearchPanelInstance = InstanceType<typeof SearchPanel>;

package/dist/components/search-panel/src/searchPanel.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, 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/components/search-panel-layout/index.d.ts

@@ -0,0 +1,6 @@
+import { default as SearchPanelLayout } from './src/layout';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcSearchPanelLayout: SFCWithInstall<typeof SearchPanelLayout>;
+export default ZjhcSearchPanelLayout;
+export * from './src/layout';
+export type { SearchPanelLayoutInstance } from './src/layout';

package/dist/components/search-panel-layout/src/layout.d.ts

@@ -0,0 +1,95 @@
+import { RendererElement, RendererNode, VNode } from 'vue';
+import { FormValidateCallback, FormItemProp, FormInstance } from 'element-plus';
+import { Arrayable } from 'element-plus/es/utils';
+declare module 'vue' {
+    interface ObjectDirective {
+        name?: string;
+    }
+}
+interface SearchPanelLayoutExpose {
+    formRef: FormInstance | undefined;
+    resetFields: () => void;
+    validate: (callback?: FormValidateCallback | undefined) => Promise<boolean>;
+    validateField: (props?: Arrayable<FormItemProp> | undefined, callback?: FormValidateCallback | undefined) => void;
+    scrollToField: (prop: FormItemProp) => void;
+    clearValidate: (props?: Arrayable<FormItemProp> | undefined) => void;
+}
+declare const SearchPanelLayout: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    gutter: {
+        type: NumberConstructor;
+        default: number;
+    };
+    enableExpand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colSpan: {
+        type: (NumberConstructor | {
+            (arrayLength: number): number[];
+            (...items: number[]): number[];
+            new (arrayLength: number): number[];
+            new (...items: number[]): number[];
+            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;
+        })[];
+        default: number;
+    };
+    collapse: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    collapseSelector: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    gutter: {
+        type: NumberConstructor;
+        default: number;
+    };
+    enableExpand: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    colSpan: {
+        type: (NumberConstructor | {
+            (arrayLength: number): number[];
+            (...items: number[]): number[];
+            new (arrayLength: number): number[];
+            new (...items: number[]): number[];
+            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;
+        })[];
+        default: number;
+    };
+    collapse: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    collapseSelector: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    gutter: number;
+    collapse: boolean;
+    enableExpand: boolean;
+    colSpan: number | number[];
+    collapseSelector: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default SearchPanelLayout;
+export type SearchPanelLayoutInstance = InstanceType<typeof SearchPanelLayout> & SearchPanelLayoutExpose;

package/dist/components/sticky-toolbar/index.d.ts

@@ -0,0 +1,6 @@
+import { default as StickyToolbar } from './src/stickyToolbar.vue';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcStickyToolbar: SFCWithInstall<typeof StickyToolbar>;
+export default ZjhcStickyToolbar;
+export * from './src/stickyToolbar.vue';
+export type { StickyToolbarInstance } from './src/instance';

package/dist/components/sticky-toolbar/src/instance.d.ts

@@ -0,0 +1,2 @@
+import { default as StickyToolbar } from './stickyToolbar.vue';
+export type StickyToolbarInstance = InstanceType<typeof StickyToolbar>;

package/dist/components/sticky-toolbar/src/stickyToolbar.vue.d.ts

@@ -0,0 +1,43 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        content?(_: {}): any;
+        toggle?(_: {}): any;
+        side?(_: {}): any;
+    };
+    refs: {
+        wrapperDom: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    selector: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>, {
+    onToggle: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    toggleEnd: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    selector: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>> & Readonly<{
+    onToggleEnd?: (...args: any[]) => any;
+}>, {
+    selector: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    wrapperDom: HTMLDivElement;
+}, 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/components/switch-mode/index.d.ts

@@ -0,0 +1,7 @@
+import { App } from 'vue';
+export declare function initMode(): void;
+export declare function switchStandardAndCareMode(mode: string, oldMode?: string): void;
+export declare const ZjhcSwitchMode: {
+    install(app: App): void;
+};
+export default ZjhcSwitchMode;

package/dist/components/switch-theme/index.d.ts

@@ -0,0 +1,7 @@
+import { App } from 'vue';
+export declare function initTheme(): void;
+export declare function changeTheme(theme: string, oldTheme?: string): void;
+export declare const ZjhcSwitchTheme: {
+    install(app: App): void;
+};
+export default ZjhcSwitchTheme;

package/dist/components/table-toolbar/index.d.ts

@@ -0,0 +1,7 @@
+import { default as TableToolbar } from './src/tableToolbar.vue';
+import { SFCWithInstall } from '../../utils';
+export declare const ZjhcTableToolbar: SFCWithInstall<typeof TableToolbar>;
+export default ZjhcTableToolbar;
+export * from './src/tableToolbar.vue';
+export * from './src/interface';
+export type TableToolbarInstance = InstanceType<typeof TableToolbar>;