zc-lowcode 0.0.1 → 0.0.2

package/dist/packages/lowcode-editor/index.vue.d.ts

@@ -0,0 +1,349 @@
+import { PropType } from 'vue';
+import { LowCodePage, WidgetContainerSchema, WidgetPackage, WidgetSchema } from '../type';
+
+declare const _default: import('vue').DefineComponent<{
+    packages: {
+        type: {
+            (arrayLength: number): WidgetPackage[];
+            (...items: WidgetPackage[]): WidgetPackage[];
+            new (arrayLength: number): WidgetPackage[];
+            new (...items: WidgetPackage[]): WidgetPackage[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    customize: {
+        type: {
+            (arrayLength: number): (WidgetSchema | WidgetContainerSchema)[];
+            (...items: (WidgetSchema | WidgetContainerSchema)[]): (WidgetSchema | WidgetContainerSchema)[];
+            new (arrayLength: number): (WidgetSchema | WidgetContainerSchema)[];
+            new (...items: (WidgetSchema | WidgetContainerSchema)[]): (WidgetSchema | WidgetContainerSchema)[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    templates: {
+        type: {
+            (arrayLength: number): LowCodePage[];
+            (...items: LowCodePage[]): LowCodePage[];
+            new (arrayLength: number): LowCodePage[];
+            new (...items: LowCodePage[]): LowCodePage[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    page: {
+        type: PropType<LowCodePage>;
+        default: () => void;
+    };
+}, {
+    designer: import('vue').Ref<{
+        page: {
+            id: number;
+            name: string;
+            previewImg?: string;
+            widgetList: ({
+                id: number;
+                type: string;
+                name: string;
+                icon?: any;
+                internal?: boolean;
+                hidden?: boolean;
+                component?: any;
+                setterComponent?: any;
+                options: any;
+            } | {
+                id: number;
+                type: string;
+                name: string;
+                icon?: any;
+                internal?: boolean;
+                hidden?: boolean;
+                component?: any;
+                setterComponent?: any;
+                options: any;
+                children: ({
+                    id: number;
+                    type: string;
+                    name: string;
+                    icon?: any;
+                    internal?: boolean;
+                    hidden?: boolean;
+                    component?: any;
+                    setterComponent?: any;
+                    options: any;
+                } | any)[];
+            })[];
+            options: {
+                backgroundColor: string;
+            };
+        };
+        selectedWidget: {
+            id: number;
+            type: string;
+            name: string;
+            icon?: any;
+            internal?: boolean;
+            hidden?: boolean;
+            component?: any;
+            setterComponent?: any;
+            options: any;
+        } | {
+            id: number;
+            type: string;
+            name: string;
+            icon?: any;
+            internal?: boolean;
+            hidden?: boolean;
+            component?: any;
+            setterComponent?: any;
+            options: any;
+            children: ({
+                id: number;
+                type: string;
+                name: string;
+                icon?: any;
+                internal?: boolean;
+                hidden?: boolean;
+                component?: any;
+                setterComponent?: any;
+                options: any;
+            } | any)[];
+        };
+        loadPage: (page: LowCodePage) => void;
+        moveUpWidget: (parentWidget: WidgetContainerSchema | undefined, index: number) => void;
+        moveDownWidget: (parentWidget: WidgetContainerSchema | undefined, index: number) => void;
+        selectParentWidget: (parentWidget: WidgetSchema | WidgetContainerSchema | null) => void;
+        copyNewWidget: (origin: WidgetSchema | WidgetContainerSchema) => any;
+        addWidget: (widget: WidgetSchema | WidgetContainerSchema, parentWidget?: WidgetContainerSchema) => void;
+        removeWidget: (widget: WidgetSchema | WidgetContainerSchema, parentWidget?: WidgetContainerSchema) => void;
+        clearWidgetList: () => void;
+        clearSelected: () => void;
+        setSelected: (widget: WidgetSchema | WidgetContainerSchema) => void;
+    }>;
+    widgetPackage: import('vue').ShallowRef<WidgetPackage[]>;
+    theme: {
+        token: any;
+        algorithm: typeof import('ant-design-vue/es/theme/themes/default').default[];
+    };
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    packages: {
+        type: {
+            (arrayLength: number): WidgetPackage[];
+            (...items: WidgetPackage[]): WidgetPackage[];
+            new (arrayLength: number): WidgetPackage[];
+            new (...items: WidgetPackage[]): WidgetPackage[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    customize: {
+        type: {
+            (arrayLength: number): (WidgetSchema | WidgetContainerSchema)[];
+            (...items: (WidgetSchema | WidgetContainerSchema)[]): (WidgetSchema | WidgetContainerSchema)[];
+            new (arrayLength: number): (WidgetSchema | WidgetContainerSchema)[];
+            new (...items: (WidgetSchema | WidgetContainerSchema)[]): (WidgetSchema | WidgetContainerSchema)[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    templates: {
+        type: {
+            (arrayLength: number): LowCodePage[];
+            (...items: LowCodePage[]): LowCodePage[];
+            new (arrayLength: number): LowCodePage[];
+            new (...items: LowCodePage[]): LowCodePage[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    page: {
+        type: PropType<LowCodePage>;
+        default: () => void;
+    };
+}>>, {
+    page: LowCodePage;
+    packages: WidgetPackage[];
+    customize: (WidgetSchema | WidgetContainerSchema)[];
+    templates: LowCodePage[];
+}, {}>;
+export default _default;
+export declare const __VLS_globalTypesStart: {};
+declare module 'vue' {
+    interface GlobalComponents {
+    }
+}
+declare global {
+    type __VLS_IntrinsicElements = import('vue/jsx-runtime').JSX.IntrinsicElements;
+    type __VLS_Element = import('vue/jsx-runtime').JSX.Element;
+    type __VLS_GlobalComponents = import('vue').GlobalComponents & Pick<typeof import('vue'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;
+    type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
+    type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
+    const __VLS_intrinsicElements: __VLS_IntrinsicElements;
+    function __VLS_getVForSourceType(source: number): [number, number, number][];
+    function __VLS_getVForSourceType(source: string): [string, number, number][];
+    function __VLS_getVForSourceType<T extends any[]>(source: T): [
+        item: T[number],
+        key: number,
+        index: number
+    ][];
+    function __VLS_getVForSourceType<T extends {
+        [Symbol.iterator](): Iterator<any>;
+    }>(source: T): [
+        item: T extends {
+            [Symbol.iterator](): Iterator<infer T1>;
+        } ? T1 : never,
+        key: number,
+        index: undefined
+    ][];
+    function __VLS_getVForSourceType<T extends number | {
+        [Symbol.iterator](): Iterator<any>;
+    }>(source: T): [
+        item: number | (Exclude<T, number> extends {
+            [Symbol.iterator](): Iterator<infer T1>;
+        } ? T1 : never),
+        key: number,
+        index: undefined
+    ][];
+    function __VLS_getVForSourceType<T>(source: T): [
+        item: T[keyof T],
+        key: keyof T,
+        index: number
+    ][];
+    function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+    function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+    function __VLS_directiveFunction<T>(dir: T): T extends import('vue').ObjectDirective<infer E, infer V> | import('vue').FunctionDirective<infer E, infer V> ? (value: V) => void : T;
+    function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+    function __VLS_makeOptional<T>(t: T): {
+        [K in keyof T]?: T[K];
+    };
+    function __VLS_nonNullable<T>(t: T): T extends null | undefined ? never : T;
+    type __VLS_SelfComponent<N, C> = string extends N ? {} : N extends string ? {
+        [P in N]: C;
+    } : {};
+    type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> = N1 extends keyof LocalComponents ? N1 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
+        [K in N0]: LocalComponents[N1];
+    } : N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
+        [K in N0]: LocalComponents[N2];
+    } : N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : {
+        [K in N0]: LocalComponents[N3];
+    } : N1 extends keyof __VLS_GlobalComponents ? N1 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
+        [K in N0]: __VLS_GlobalComponents[N1];
+    } : N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
+        [K in N0]: __VLS_GlobalComponents[N2];
+    } : N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : {
+        [K in N0]: __VLS_GlobalComponents[N3];
+    } : {
+        [K in N0]: unknown;
+    };
+    function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K): T extends new (...args: any) => any ? (props: (K extends {
+        $props: infer Props;
+    } ? Props : any) & Record<string, unknown>, ctx?: any) => __VLS_Element & {
+        __ctx?: {
+            attrs?: any;
+            slots?: K extends {
+                $slots: infer Slots;
+            } ? Slots : any;
+            emit?: K extends {
+                $emit: infer Emit;
+            } ? Emit : any;
+        } & {
+            props?: (K extends {
+                $props: infer Props;
+            } ? Props : any) & Record<string, unknown>;
+            expose?(exposed: K): void;
+        };
+    } : T extends () => any ? (props: {}, ctx?: any) => ReturnType<T> : T extends (...args: any) => any ? T : (_: {} & Record<string, unknown>, ctx?: any) => {
+        __ctx?: {
+            attrs?: any;
+            expose?: any;
+            slots?: any;
+            emit?: any;
+            props?: {} & Record<string, unknown>;
+        };
+    };
+    function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T & Record<string, unknown>) => void;
+    function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
+    function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): __VLS_PickNotAny<'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends {
+        __ctx?: infer Ctx;
+    } ? Ctx : never : any, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any>;
+    type __VLS_FunctionalComponentProps<T, K> = '__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends {
+        __ctx?: {
+            props?: infer P;
+        };
+    } ? NonNullable<P> : never : T extends (props: infer P, ...args: any) => any ? P : {};
+    type __VLS_IsFunction<T, K> = K extends keyof T ? __VLS_IsAny<T[K]> extends false ? unknown extends T[K] ? false : true : false : false;
+    function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+    /**
+     * emit
+     */
+    type __VLS_UnionToIntersection<U> = (U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never;
+    type __VLS_OverloadUnionInner<T, U = unknown> = U & T extends (...args: infer A) => infer R ? U extends T ? never : __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R) : never;
+    type __VLS_OverloadUnion<T> = Exclude<__VLS_OverloadUnionInner<(() => never) & T>, T extends () => never ? never : () => never>;
+    type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F ? F extends (event: infer E, ...args: infer A) => any ? {
+        [K in E & string]: (...args: A) => void;
+    } : never : never;
+    type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<__VLS_UnionToIntersection<__VLS_ConstructorOverloads<T> & {
+        [K in keyof T]: T[K] extends any[] ? {
+            (...args: T[K]): void;
+        } : never;
+    }>>;
+    type __VLS_PrettifyGlobal<T> = {
+        [K in keyof T]: T[K];
+    } & {};
+}
+export declare const __VLS_globalTypesEnd: {};

package/dist/packages/lowcode-editor-renderer/index.vue.d.ts

@@ -0,0 +1,100 @@
+import { PropType } from 'vue';
+import { LowCodePage, WidgetContainerSchema, WidgetPackage, WidgetSchema } from '../type';
+
+declare const _default: import('vue').DefineComponent<{
+    packages: {
+        type: {
+            (arrayLength: number): WidgetPackage[];
+            (...items: WidgetPackage[]): WidgetPackage[];
+            new (arrayLength: number): WidgetPackage[];
+            new (...items: WidgetPackage[]): WidgetPackage[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    customize: {
+        type: {
+            (arrayLength: number): (WidgetSchema | WidgetContainerSchema)[];
+            (...items: (WidgetSchema | WidgetContainerSchema)[]): (WidgetSchema | WidgetContainerSchema)[];
+            new (arrayLength: number): (WidgetSchema | WidgetContainerSchema)[];
+            new (...items: (WidgetSchema | WidgetContainerSchema)[]): (WidgetSchema | WidgetContainerSchema)[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    page: {
+        type: PropType<LowCodePage>;
+        default: () => void;
+    };
+}, {
+    widgetList: (WidgetSchema | WidgetContainerSchema)[];
+    pageStyle: import('vue').ComputedRef<{
+        backgroundColor: string;
+    }>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    packages: {
+        type: {
+            (arrayLength: number): WidgetPackage[];
+            (...items: WidgetPackage[]): WidgetPackage[];
+            new (arrayLength: number): WidgetPackage[];
+            new (...items: WidgetPackage[]): WidgetPackage[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    customize: {
+        type: {
+            (arrayLength: number): (WidgetSchema | WidgetContainerSchema)[];
+            (...items: (WidgetSchema | WidgetContainerSchema)[]): (WidgetSchema | WidgetContainerSchema)[];
+            new (arrayLength: number): (WidgetSchema | WidgetContainerSchema)[];
+            new (...items: (WidgetSchema | WidgetContainerSchema)[]): (WidgetSchema | WidgetContainerSchema)[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => any[];
+    };
+    page: {
+        type: PropType<LowCodePage>;
+        default: () => void;
+    };
+}>>, {
+    page: LowCodePage;
+    packages: WidgetPackage[];
+    customize: (WidgetSchema | WidgetContainerSchema)[];
+}, {}>;
+export default _default;

package/dist/packages/lowcode-editor-widgets/components/property-editor/property.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    methods: {};
+};
+export default _default;

package/dist/packages/lowcode-editor-widgets/components/property.vue.d.ts

@@ -0,0 +1,53 @@
+import { PropType } from 'vue';
+import { WidgetContainerSchema, WidgetSchema } from '../../type';
+
+declare const _default: import('vue').DefineComponent<{
+    options: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+    widget: {
+        type: PropType<WidgetContainerSchema | WidgetSchema>;
+        required: true;
+    };
+}, unknown, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    options: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            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[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: true;
+    };
+    widget: {
+        type: PropType<WidgetContainerSchema | WidgetSchema>;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _default;

package/dist/packages/lowcode-editor-widgets/components/setter-base/index.vue.d.ts

@@ -0,0 +1,20 @@
+import { WidgetContainerSchema, WidgetSchema } from '../../../type';
+import { PropType } from 'vue';
+
+declare const _default: import('vue').DefineComponent<{
+    widget: {
+        type: PropType<WidgetSchema | WidgetContainerSchema>;
+        required: true;
+    };
+}, {
+    keys: import('vue').Ref<string[]>;
+    common: any;
+    advanced: any;
+    event: any;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    widget: {
+        type: PropType<WidgetSchema | WidgetContainerSchema>;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _default;

package/dist/packages/lowcode-editor-widgets/components/usePropertyRegister.d.ts

@@ -0,0 +1,7 @@
+import { WidgetContainerSchema, WidgetSchema } from '../../type';
+
+export declare function usePropertyRegister(widget: WidgetContainerSchema | WidgetSchema): {
+    common: any;
+    advanced: any;
+    event: any;
+};

package/dist/packages/lowcode-editor-widgets/index.d.ts

@@ -0,0 +1,4 @@
+import { WidgetPackage } from '../type';
+
+declare const widgetGroups: Array<WidgetPackage>;
+export default widgetGroups;

package/dist/packages/lowcode-editor-widgets/widgets/container/card/index.d.ts

@@ -0,0 +1,38 @@
+declare const _default: {
+    id: number;
+    type: string;
+    name: string;
+    hidden: boolean;
+    icon: string;
+    children: any[];
+    options: {
+        name: string;
+        cols: any[];
+        gutter: number;
+        colHeight: any;
+        customClass: string;
+    };
+    component: import('vue').DefineComponent<{
+        widget: {
+            type: import('vue').PropType<import('../../../../type').WidgetSchema>;
+            required: true;
+        };
+    }, unknown, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        widget: {
+            type: import('vue').PropType<import('../../../../type').WidgetSchema>;
+            required: true;
+        };
+    }>>, {}, {}>;
+    setterComponent: import('vue').DefineComponent<{
+        widget: {
+            type: import('vue').PropType<import('../../../../type').WidgetSchema>;
+            required: true;
+        };
+    }, unknown, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        widget: {
+            type: import('vue').PropType<import('../../../../type').WidgetSchema>;
+            required: true;
+        };
+    }>>, {}, {}>;
+};
+export default _default;

package/dist/packages/lowcode-editor-widgets/widgets/container/card/setter.vue.d.ts

@@ -0,0 +1,15 @@
+import { WidgetSchema } from '../../../../type';
+import { PropType } from 'vue';
+
+declare const _default: import('vue').DefineComponent<{
+    widget: {
+        type: PropType<WidgetSchema>;
+        required: true;
+    };
+}, unknown, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    widget: {
+        type: PropType<WidgetSchema>;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _default;

package/dist/packages/lowcode-editor-widgets/widgets/container/card/view.vue.d.ts

@@ -0,0 +1,15 @@
+import { WidgetSchema } from '../../../../type';
+import { PropType } from 'vue';
+
+declare const _default: import('vue').DefineComponent<{
+    widget: {
+        type: PropType<WidgetSchema>;
+        required: true;
+    };
+}, unknown, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    widget: {
+        type: PropType<WidgetSchema>;
+        required: true;
+    };
+}>>, {}, {}>;
+export default _default;