import { AllowedComponentProps } from 'vue';
import { App } from 'vue';
import { ComponentCustomProperties } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentInternalInstance } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { DebuggerEvent } from 'vue';
import { DefineComponent } from 'vue';
import { ExtractPropTypes } from 'vue';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { Handler } from 'mitt';
import { nextTick } from 'vue';
import { OnCleanup } from '@vue/reactivity';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { Router } from 'vue-router';
import { RouteRecordRaw } from 'vue-router';
import { ShallowUnwrapRef } from 'vue';
import { Slot } from 'vue';
import { useRoute } from 'vue-router';
import { useRouter } from 'vue-router';
import { VNodeProps } from 'vue';
import { WatchOptions } from 'vue';
import { WatchStopHandle } from 'vue';
import { WildcardHandler } from 'mitt';

declare const __VLS_component: DefineComponent<ExtractPropTypes<    {
config: {
type: ObjectConstructor;
required: true;
};
module: {
type: StringConstructor;
default: string;
};
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
data: {
type: PropType<ListData>;
default: () => {
count: number;
listdata: never[];
};
};
}>, {
GetSelectedItems: () => SelectedItem[];
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
config: {
type: ObjectConstructor;
required: true;
};
module: {
type: StringConstructor;
default: string;
};
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
data: {
type: PropType<ListData>;
default: () => {
count: number;
listdata: never[];
};
};
}>> & Readonly<{}>, {
data: ListData;
module: string;
pre_selection: SelectedItem[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {
tableRef: unknown;
}, HTMLDivElement>;

declare const __VLS_component_2: DefineComponent<ExtractPropTypes<    {
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
listconfig: {
type: PropType<ListConfig>;
required: true;
};
quantity: {
type: NumberConstructor;
default: number;
};
dialog_config: {
type: PropType<DialogConfig>;
};
}>, {
GetSelectedItems: () => SelectedItem[];
OpenDialog: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
dialog_sure: (value: SelectedItem[]) => any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
listconfig: {
type: PropType<ListConfig>;
required: true;
};
quantity: {
type: NumberConstructor;
default: number;
};
dialog_config: {
type: PropType<DialogConfig>;
};
}>> & Readonly<{
onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
}>, {
pre_selection: SelectedItem[];
quantity: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_3: DefineComponent<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
required: true;
};
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
listconfig: {
type: PropType<ListConfig>;
required: true;
};
dialog_config: {
type: PropType<DialogConfig>;
default: {
Title: string;
Width: number;
Height: number;
};
};
quantity: {
type: NumberConstructor;
default: number;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:modelValue": (value: boolean) => any;
sure: (value: SelectedItem[]) => any;
close: () => any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
modelValue: {
type: BooleanConstructor;
required: true;
};
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
listconfig: {
type: PropType<ListConfig>;
required: true;
};
dialog_config: {
type: PropType<DialogConfig>;
default: {
Title: string;
Width: number;
Height: number;
};
};
quantity: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{
"onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
onSure?: ((value: SelectedItem[]) => any) | undefined;
onClose?: (() => any) | undefined;
}>, {
pre_selection: SelectedItem[];
dialog_config: DialogConfig;
quantity: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {
list: ({
$: ComponentInternalInstance;
$data: {};
$props: Partial<{
data: ListData;
module: string;
pre_selection: SelectedItem[];
}> & Omit<{
readonly data: ListData;
readonly module: string;
readonly config: Record<string, any>;
readonly pre_selection: SelectedItem[];
} & VNodeProps & AllowedComponentProps & ComponentCustomProps, "data" | "module" | "pre_selection">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
} & {
tableRef: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: (event: string, ...args: any[]) => void;
$el: HTMLDivElement;
$options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
config: {
type: ObjectConstructor;
required: true;
};
module: {
type: StringConstructor;
default: string;
};
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
data: {
type: PropType<ListData>;
default: () => {
count: number;
listdata: never[];
};
};
}>> & Readonly<{}>, {
GetSelectedItems: () => SelectedItem[];
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
data: ListData;
module: string;
pre_selection: SelectedItem[];
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
data: ListData;
module: string;
pre_selection: SelectedItem[];
}> & Omit<Readonly<ExtractPropTypes<    {
config: {
type: ObjectConstructor;
required: true;
};
module: {
type: StringConstructor;
default: string;
};
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
data: {
type: PropType<ListData>;
default: () => {
count: number;
listdata: never[];
};
};
}>> & Readonly<{}>, "GetSelectedItems" | ("data" | "module" | "pre_selection")> & ShallowUnwrapRef<    {
GetSelectedItems: () => SelectedItem[];
}> & {} & ComponentCustomProperties & {} & {
$slots: {
headermain?(_: {}): any;
custom_search?(_: {}): any;
content?(_: {}): any;
};
}) | null;
}, any>;

declare const __VLS_component_4: DefineComponent<ExtractPropTypes<    {
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
quantity: {
type: NumberConstructor;
default: number;
};
}>, {
GetSelectedItems: () => SelectedItem[];
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
dialog_sure: (value: SelectedItem[]) => any;
}, string, PublicProps, Readonly<ExtractPropTypes<    {
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
quantity: {
type: NumberConstructor;
default: number;
};
}>> & Readonly<{
onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
}>, {
pre_selection: SelectedItem[];
quantity: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {
s: ({
$: ComponentInternalInstance;
$data: {};
$props: Partial<{
pre_selection: SelectedItem[];
quantity: number;
}> & Omit<{
readonly pre_selection: SelectedItem[];
readonly listconfig: ListConfig;
readonly quantity: number;
readonly dialog_config?: DialogConfig | undefined;
readonly onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps, "pre_selection" | "quantity">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: (event: "dialog_sure", value: SelectedItem[]) => void;
$el: any;
$options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
listconfig: {
type: PropType<ListConfig>;
required: true;
};
quantity: {
type: NumberConstructor;
default: number;
};
dialog_config: {
type: PropType<DialogConfig>;
};
}>> & Readonly<{
onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
}>, {
GetSelectedItems: () => SelectedItem[];
OpenDialog: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
dialog_sure: (value: SelectedItem[]) => any;
}, string, {
pre_selection: SelectedItem[];
quantity: number;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
pre_selection: SelectedItem[];
quantity: number;
}> & Omit<Readonly<ExtractPropTypes<    {
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
listconfig: {
type: PropType<ListConfig>;
required: true;
};
quantity: {
type: NumberConstructor;
default: number;
};
dialog_config: {
type: PropType<DialogConfig>;
};
}>> & Readonly<{
onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
}>, "GetSelectedItems" | "OpenDialog" | ("pre_selection" | "quantity")> & ShallowUnwrapRef<    {
GetSelectedItems: () => SelectedItem[];
OpenDialog: () => void;
}> & {} & ComponentCustomProperties & {} & {
$slots: {
default?(_: {
methods: {
OpenDialog: () => void;
};
}): any;
dialoglist?(_: {}): any;
};
}) | null;
}, any>;

declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: {
        headermain?(_: {}): any;
        custom_search?(_: {}): any;
        content?(_: {}): any;
    };
    refs: {
        tableRef: unknown;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_2(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {
            methods: {
                OpenDialog: () => void;
            };
        }): any;
        dialoglist?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_3(): {
    attrs: Partial<{}>;
    slots: {
        dialoglist?(_: {}): any;
    };
    refs: {
        list: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                data: ListData;
                module: string;
                pre_selection: SelectedItem[];
            }> & Omit<{
                readonly data: ListData;
                readonly module: string;
                readonly config: Record<string, any>;
                readonly pre_selection: SelectedItem[];
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "data" | "module" | "pre_selection">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            } & {
                tableRef: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: HTMLDivElement;
            $options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
            config: {
            type: ObjectConstructor;
            required: true;
            };
            module: {
            type: StringConstructor;
            default: string;
            };
            pre_selection: {
            type: PropType<SelectedItem[]>;
            default: never[];
            };
            data: {
            type: PropType<ListData>;
            default: () => {
            count: number;
            listdata: never[];
            };
            };
            }>> & Readonly<{}>, {
            GetSelectedItems: () => SelectedItem[];
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
            data: ListData;
            module: string;
            pre_selection: SelectedItem[];
            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{
            data: ListData;
            module: string;
            pre_selection: SelectedItem[];
        }> & Omit<Readonly<ExtractPropTypes<    {
        config: {
        type: ObjectConstructor;
        required: true;
        };
        module: {
        type: StringConstructor;
        default: string;
        };
        pre_selection: {
        type: PropType<SelectedItem[]>;
        default: never[];
        };
        data: {
        type: PropType<ListData>;
        default: () => {
        count: number;
        listdata: never[];
        };
        };
        }>> & Readonly<{}>, "GetSelectedItems" | ("data" | "module" | "pre_selection")> & ShallowUnwrapRef<    {
        GetSelectedItems: () => SelectedItem[];
        }> & {} & ComponentCustomProperties & {} & {
            $slots: {
                headermain?(_: {}): any;
                custom_search?(_: {}): any;
                content?(_: {}): any;
            };
        }) | null;
    };
    rootEl: any;
};

declare function __VLS_template_4(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {
            methods: {
                OpenDialog: () => void;
            };
        }): any;
    };
    refs: {
        s: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                pre_selection: SelectedItem[];
                quantity: number;
            }> & Omit<{
                readonly pre_selection: SelectedItem[];
                readonly listconfig: ListConfig;
                readonly quantity: number;
                readonly dialog_config?: DialogConfig | undefined;
                readonly onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps, "pre_selection" | "quantity">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: "dialog_sure", value: SelectedItem[]) => void;
            $el: any;
            $options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
            pre_selection: {
            type: PropType<SelectedItem[]>;
            default: never[];
            };
            listconfig: {
            type: PropType<ListConfig>;
            required: true;
            };
            quantity: {
            type: NumberConstructor;
            default: number;
            };
            dialog_config: {
            type: PropType<DialogConfig>;
            };
            }>> & Readonly<{
            onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
            }>, {
            GetSelectedItems: () => SelectedItem[];
            OpenDialog: () => void;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
            dialog_sure: (value: SelectedItem[]) => any;
            }, string, {
            pre_selection: SelectedItem[];
            quantity: number;
            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{
            pre_selection: SelectedItem[];
            quantity: number;
        }> & Omit<Readonly<ExtractPropTypes<    {
        pre_selection: {
        type: PropType<SelectedItem[]>;
        default: never[];
        };
        listconfig: {
        type: PropType<ListConfig>;
        required: true;
        };
        quantity: {
        type: NumberConstructor;
        default: number;
        };
        dialog_config: {
        type: PropType<DialogConfig>;
        };
        }>> & Readonly<{
            onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
        }>, "GetSelectedItems" | "OpenDialog" | ("pre_selection" | "quantity")> & ShallowUnwrapRef<    {
        GetSelectedItems: () => SelectedItem[];
        OpenDialog: () => void;
        }> & {} & ComponentCustomProperties & {} & {
            $slots: {
                default?(_: {
                    methods: {
                        OpenDialog: () => void;
                    };
                }): any;
                dialoglist?(_: {}): any;
            };
        }) | null;
    };
    rootEl: any;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;

declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

export declare const AddClientUrl: (url: string, clientUrl: string) => void;

export declare const addFrameRouter: (r: RouteRecordRaw) => void;

export declare const addFrameRouters: (rs: RouteRecordRaw[]) => void;

export declare const breadcrumb: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface DialogConfig {
    Title?: string;
    Width?: number;
    Height?: number;
}

declare type Events = {
    'aud': {
        module: string;
        id: bigint;
    };
};

declare interface ExportColumn {
    ColumnTitle: string;
    ColumnName: string;
}

/**
 * 格式化日期为 YYYY-MM-DD HH:mm:ss 格式
 * @param date 可被Date解析的任何值
 * @returns 格式化后的日期字符串
 */
export declare function formatDateTime(date: Date | string | number): string;

export declare const formatPreciseOralTime: (timestamp: string | Date) => string;

export declare function GetAppName(): Promise<string>;

export declare const GetItemsIds: (arr: SelectedItem[]) => string;

export declare const GetItemsTitles: (arr: SelectedItem[]) => string;

export declare function GetOrganizationName(): Promise<string>;

export declare function GetOrganizationShortName(): Promise<string>;

export declare function GetUserPermission(): Promise<string[]>;

export declare function HasClientUrl(url: string): boolean;

export declare function HasPermission(p: string): Promise<boolean>;

export declare class httpapi {
    static api_host: string;
    static url_login: string;
    static url_login_vc: string;
    static url_usercenter: string;
    static url_change_password: string;
    static url_user_change_pwd_by_username: string;
    static url_user_change_pwd_by_username_vc: string;
    static url_user_permission: string;
    static url_notification_list: string;
    static url_notification_read: string;
    static url_notification_all_read: string;
    static url_user_save: string;
    static url_user_list: string;
    static url_user_export: string;
    static url_user_del: string;
    static url_user_detail: string;
    static url_user_change_pwd: string;
    static url_user_module_setting_get: string;
    static url_user_module_setting_save: string;
    static url_user_unlock: string;
    static url_department_save: string;
    static url_department_list: string;
    static url_department_del: string;
    static url_department_detail: string;
    static url_position_list: string;
    static url_position_detail: string;
    static url_position_save: string;
    static url_position_del: string;
    static url_syslog_list: string;
    static url_syslog_config_detail: string;
    static url_syslog_config_save: string;
    static url_backup_start: string;
    static url_backup_list: string;
    static url_backup_del: string;
    static url_backup_config_get: string;
    static url_backup_config_save: string;
    static url_system_setting_save: string;
    static url_syspermission_list: string;
    static url_sysrole_list: string;
    static url_sysrole_del: string;
    static url_sysrole_save: string;
    static url_sysrole_detail: string;
    static url_export_detail: string;
    static url_export_file: string;
    static url_system_version: string;
    static url_system_version_history: string;
    static url_system_public: string;
    static url_system_common_info: string;
    static GetFullApiUrl(api: string): string;
    static Post(url: string, obj: object): Promise<HttpApiReturnData>;
}

export declare class HttpApiReturnData {
    error_code: number;
    message: string;
    data: object;
    constructor();
    get IsSuccess(): boolean;
    static fromObject(obj: Partial<HttpApiReturnData>): HttpApiReturnData;
}

export declare const list_filter_node_selector: DefineComponent<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
column: {
type: StringConstructor;
required: true;
};
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
quantity: {
type: NumberConstructor;
default: number;
};
url: {
type: StringConstructor;
default: string;
};
}>, {
GetSqlQueryParam: () => SqlQueryParam | null;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
title: {
type: StringConstructor;
default: string;
};
column: {
type: StringConstructor;
required: true;
};
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
quantity: {
type: NumberConstructor;
default: number;
};
url: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
url: string;
title: string;
pre_selection: SelectedItem[];
quantity: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {
s: ({
$: ComponentInternalInstance;
$data: {};
$props: Partial<{
pre_selection: SelectedItem[];
quantity: number;
}> & Omit<{
readonly pre_selection: SelectedItem[];
readonly listconfig: ListConfig;
readonly quantity: number;
readonly dialog_config?: DialogConfig | undefined;
readonly onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps, "pre_selection" | "quantity">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: (event: "dialog_sure", value: SelectedItem[]) => void;
$el: any;
$options: ComponentOptionsBase<Readonly<ExtractPropTypes<    {
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
listconfig: {
type: PropType<ListConfig>;
required: true;
};
quantity: {
type: NumberConstructor;
default: number;
};
dialog_config: {
type: PropType<DialogConfig>;
};
}>> & Readonly<{
onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
}>, {
GetSelectedItems: () => SelectedItem[];
OpenDialog: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
dialog_sure: (value: SelectedItem[]) => any;
}, string, {
pre_selection: SelectedItem[];
quantity: number;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, 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: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
pre_selection: SelectedItem[];
quantity: number;
}> & Omit<Readonly<ExtractPropTypes<    {
pre_selection: {
type: PropType<SelectedItem[]>;
default: never[];
};
listconfig: {
type: PropType<ListConfig>;
required: true;
};
quantity: {
type: NumberConstructor;
default: number;
};
dialog_config: {
type: PropType<DialogConfig>;
};
}>> & Readonly<{
onDialog_sure?: ((value: SelectedItem[]) => any) | undefined;
}>, "GetSelectedItems" | "OpenDialog" | ("pre_selection" | "quantity")> & ShallowUnwrapRef<    {
GetSelectedItems: () => SelectedItem[];
OpenDialog: () => void;
}> & {} & ComponentCustomProperties & {} & {
$slots: {
default?(_: {
methods: {
OpenDialog: () => void;
};
}): any;
dialoglist?(_: {}): any;
};
}) | null;
}, any>;

export declare interface ListConfig {
    ApiUrl: string;
    QuickConditionsGroups?: QuickConditionsGroup[];
    HideBottomToolbar?: boolean;
    KeywordTip?: string;
    ExportUrl?: string;
    ExportColumn?: ExportColumn[];
    HasCheckbox?: boolean;
    ReserveSelection?: boolean;
    RowIdKey?: string | ((row: any) => string);
    RowTitleKey?: string;
    CanRowSelect?: boolean;
    SelectQuantity?: number;
    LeftPanel?: boolean;
    FilterComponents?: Ref[];
    FilterParam?: SqlQueryParam[];
}

export declare interface ListData {
    count: number;
    listdata: [] | any[];
}

export declare const OpenClientUrlWithID: (url: string, id: any) => void;

declare interface QuickConditionsGroup {
    Label: string;
    QuickConditions: SqlQueryParam[];
    Select: number;
}

export declare const router: Router;

export declare interface SelectedItem {
    title: string;
    id: bigint;
}

declare interface SqlQueryParam {
    label: string;
    column: string | null;
    condition?: string | null | unknown;
    value?: number | string | Array<Object> | null | unknown;
}

export { useRoute }

export { useRouter }

export declare const zsys_delbutton: DefineComponent<ExtractPropTypes<    {
id: {
type: PropType<bigint>;
required: true;
};
api_url: {
type: StringConstructor;
required: true;
};
module: {
type: StringConstructor;
default: string;
};
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
id: {
type: PropType<bigint>;
required: true;
};
api_url: {
type: StringConstructor;
required: true;
};
module: {
type: StringConstructor;
default: string;
};
}>> & Readonly<{}>, {
module: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

export declare const zsys_selector: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;

export declare const zsys_selector_dialog: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;

export declare const zsys_user_selctor: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;

export declare const zsysapp: App<Element>;

export declare function zsysappMount(): void;

export declare const zsysEventBus: () => {
    emit: {
        <Key extends "aud">(type: Key, event: Events[Key]): void;
        <Key extends "aud">(type: undefined extends Events[Key] ? Key : never): void;
    };
    on: {
        <Key extends "aud">(type: Key, handler: Handler<Events[Key]>): void;
        (type: "*", handler: WildcardHandler<Events>): void;
    };
    off: {
        <Key extends "aud">(type: Key, handler?: Handler<Events[Key]> | undefined): void;
        (type: "*", handler: WildcardHandler<Events>): void;
    };
    once: <T extends keyof Events>(event: T, handler: (payload: Events[T]) => void) => void;
    clearAll: () => void;
};

export declare const zsyslist: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

export declare class ZSYSMessage {
    static show(msgType: "success" | "warning" | "info" | "error" | undefined, msg: string): void;
    static ShowInfo(msg: string): void;
    static ShowWarn(msg: string): void;
    static ShowSuccess(msg: string): void;
    static ShowError(msg: string): void;
    install: (app: App) => App<any>;
}

export { }