@vtj/ui 0.0.6 → 0.4.1

package/types/components/tool/tool.d.ts

@@ -0,0 +1,91 @@
+import { EpPropFinalized, Arrayable, EpPropMergeType } from 'element-plus/es/utils';
+import { PropType, ExtractPropTypes } from 'vue';
+import { TooltipTriggerType, Placement, Options, ButtonProps, dropdownProps, BadgeProps, ElTooltipProps } from 'element-plus';
+import { UnReadOnly, Emits, IconParam, IconSize } from '../..';
+export type ToolValue = string | number | symbol | undefined;
+export interface ToolMenu {
+    label: string;
+    value: ToolValue;
+    closable?: boolean;
+    icon?: IconParam;
+    disabled?: boolean;
+    divided?: boolean;
+}
+export type ToolDropDown = UnReadOnly<ExtractPropTypes<typeof dropdownProps>>;
+export type ToolBadgeProps = UnReadOnly<Partial<BadgeProps>>;
+export type ToolTooltipProps = UnReadOnly<Partial<ElTooltipProps>>;
+export declare const toolProps: {
+    label: {
+        type: StringConstructor;
+    };
+    value: {
+        type: PropType<ToolValue>;
+    };
+    icon: {
+        type: PropType<IconParam>;
+    };
+    size: {
+        type: PropType<IconSize>;
+    };
+    disabled: {
+        type: PropType<boolean | (() => boolean)>;
+    };
+    menus: {
+        type: PropType<ToolMenu[]>;
+    };
+    active: {
+        type: (StringConstructor | NumberConstructor | ObjectConstructor)[];
+    };
+    dropdown: {
+        type: PropType<UnReadOnly<ExtractPropTypes<{
+            readonly trigger: EpPropFinalized<(new (...args: any[]) => "contextmenu" | "hover" | "focus" | "click" | TooltipTriggerType[]) | (() => Arrayable<TooltipTriggerType>) | ((new (...args: any[]) => "contextmenu" | "hover" | "focus" | "click" | TooltipTriggerType[]) | (() => Arrayable<TooltipTriggerType>))[], unknown, unknown, "hover", boolean>;
+            readonly effect: {
+                readonly default: "light";
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                readonly __epPropKey: true;
+            };
+            readonly type: {
+                readonly type: PropType<EpPropMergeType<(new (...args: any[]) => "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger") | (() => EpPropMergeType<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown>) | ((new (...args: any[]) => "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger") | (() => EpPropMergeType<StringConstructor, "" | "default" | "text" | "success" | "warning" | "info" | "primary" | "danger", unknown>))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly placement: EpPropFinalized<(new (...args: any[]) => "auto" | "bottom" | "auto-start" | "auto-end" | "top" | "right" | "left" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | ((new (...args: any[]) => "auto" | "bottom" | "auto-start" | "auto-end" | "top" | "right" | "left" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement))[], unknown, unknown, "bottom", boolean>;
+            readonly popperOptions: EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | ((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>))[], unknown, unknown, () => {}, boolean>;
+            readonly id: StringConstructor;
+            readonly size: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly splitButton: BooleanConstructor;
+            readonly hideOnClick: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly loop: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showTimeout: EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+            readonly hideTimeout: EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+            readonly tabindex: EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, 0, boolean>;
+            readonly maxHeight: EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | ((new (...args: any[]) => string | number) | (() => string | number))[], unknown, unknown, "", boolean>;
+            readonly popperClass: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+            readonly role: EpPropFinalized<StringConstructor, unknown, unknown, "menu", boolean>;
+            readonly buttonProps: {
+                readonly type: PropType<ButtonProps>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly teleported: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        }>>>;
+    };
+    badge: {
+        type: PropType<number | UnReadOnly<Partial<BadgeProps>>>;
+    };
+    tooltip: {
+        type: PropType<string | UnReadOnly<Partial<ElTooltipProps>>>;
+    };
+};
+export declare const toolEmits: {
+    click: (value: ToolValue) => boolean;
+    command: (menu: ToolMenu) => boolean;
+    close: (menu: ToolMenu) => boolean;
+};
+export type ToolProps = Partial<ExtractPropTypes<typeof toolProps>>;
+export type ToolEmits = Emits<typeof toolEmits>;

package/types/components/toolbar/Toolbar.vue.d.ts

@@ -0,0 +1,44 @@
+import { ToolbarButtonGroup, ToolbarItem, ToolValue, ToolMenu } from '../..';
+import { DefineComponent, PropType, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, ExtractPropTypes } from 'vue';
+declare const _default: __VLS_WithTemplateSlots<DefineComponent<{
+    button: {
+        type: PropType<ToolbarButtonGroup>;
+    };
+    items: {
+        type: PropType<ToolbarItem[]>;
+        default: () => never[];
+    };
+    hiddenOnDisabled: {
+        type: BooleanConstructor;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    click: (value?: ToolValue) => boolean;
+    command: (value: ToolValue, menu: ToolMenu) => boolean;
+    close: (value: ToolValue, menu: ToolMenu) => boolean;
+}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
+    button: {
+        type: PropType<ToolbarButtonGroup>;
+    };
+    items: {
+        type: PropType<ToolbarItem[]>;
+        default: () => never[];
+    };
+    hiddenOnDisabled: {
+        type: BooleanConstructor;
+    };
+}>> & {
+    onClick?: ((value?: ToolValue) => any) | undefined;
+    onClose?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+    onCommand?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+}, {
+    items: ToolbarItem[];
+    hiddenOnDisabled: boolean;
+}, {}>, Partial<Record<string, (_: {
+    item: ToolbarItem;
+}) => any>>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/types/components/toolbar/hooks.d.ts

@@ -0,0 +1,14 @@
+import { ComputedRef } from 'vue';
+import { ToolbarItem, ToolbarProps, ToolbarEmits } from './toolbar';
+import { ToolMenu } from '../..';
+export declare function useDisabled(disabled?: boolean | (() => boolean)): boolean | undefined;
+export declare function useProps(props: ToolbarProps): {
+    mergeButtonProps: (item: ToolbarItem, disabled?: boolean | (() => boolean)) => Record<string, any>;
+    mergeToolProps: (item: ToolbarItem) => Record<string, any>;
+    visibleItems: ComputedRef<ToolbarItem[] | undefined>;
+};
+export declare function useEvents(props: ToolbarProps, emit: ToolbarEmits): {
+    onClick: (value: any) => void;
+    onCommand: (value: any, menu: ToolMenu) => void;
+    onClose: (value: any, menu: ToolMenu) => void;
+};

package/types/components/toolbar/index.d.ts

@@ -0,0 +1,161 @@
+import { ComponentInternalInstance, VNodeRef, VNode, RendererNode, RendererElement, Slot, ComponentPublicInstance, ComponentOptionsBase, ExtractPropTypes, PropType, ComponentOptionsMixin, DebuggerEvent, nextTick, WatchOptions, WatchStopHandle, ShallowUnwrapRef, ComponentCustomProperties, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
+import { WithInstall, ToolbarItem, ToolbarButtonGroup, ToolValue, ToolMenu } from '../..';
+export declare const XToolbar: WithInstall<{
+    new (...args: any[]): {
+        $: ComponentInternalInstance;
+        $data: {};
+        $props: {
+            items?: ToolbarItem[] | undefined;
+            hiddenOnDisabled?: boolean | undefined;
+            key?: string | number | symbol | undefined;
+            ref?: VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            onVnodeBeforeMount?: ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: VNode<RendererNode, RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            class?: unknown;
+            style?: unknown;
+            readonly button?: ToolbarButtonGroup | undefined;
+            onClick?: ((value?: ToolValue) => any) | undefined;
+            onClose?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+            onCommand?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $parent: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $emit: ((event: "click", value?: ToolValue) => void) & ((event: "command", value: ToolValue, menu: ToolMenu) => void) & ((event: "close", value: ToolValue, menu: ToolMenu) => void);
+        $el: any;
+        $options: ComponentOptionsBase<Readonly<ExtractPropTypes<{
+            button: {
+                type: PropType<ToolbarButtonGroup>;
+            };
+            items: {
+                type: PropType<ToolbarItem[]>;
+                default: () => never[];
+            };
+            hiddenOnDisabled: {
+                type: BooleanConstructor;
+            };
+        }>> & {
+            onClick?: ((value?: ToolValue) => any) | undefined;
+            onClose?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+            onCommand?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+        }, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            click: (value?: ToolValue) => boolean;
+            command: (value: ToolValue, menu: ToolMenu) => boolean;
+            close: (value: ToolValue, menu: ToolMenu) => boolean;
+        }, string, {
+            items: ToolbarItem[];
+            hiddenOnDisabled: boolean;
+        }, {}, string, {}> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: WatchOptions<boolean> | undefined): WatchStopHandle;
+    } & Readonly<ExtractPropTypes<{
+        button: {
+            type: PropType<ToolbarButtonGroup>;
+        };
+        items: {
+            type: PropType<ToolbarItem[]>;
+            default: () => never[];
+        };
+        hiddenOnDisabled: {
+            type: BooleanConstructor;
+        };
+    }>> & {
+        onClick?: ((value?: ToolValue) => any) | undefined;
+        onClose?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+        onCommand?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+    } & ShallowUnwrapRef<{}> & {} & ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & ComponentOptionsBase<Readonly<ExtractPropTypes<{
+    button: {
+        type: PropType<ToolbarButtonGroup>;
+    };
+    items: {
+        type: PropType<ToolbarItem[]>;
+        default: () => never[];
+    };
+    hiddenOnDisabled: {
+        type: BooleanConstructor;
+    };
+}>> & {
+    onClick?: ((value?: ToolValue) => any) | undefined;
+    onClose?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+    onCommand?: ((value: ToolValue, menu: ToolMenu) => any) | undefined;
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    click: (value?: ToolValue) => boolean;
+    command: (value: ToolValue, menu: ToolMenu) => boolean;
+    close: (value: ToolValue, menu: ToolMenu) => boolean;
+}, string, {
+    items: ToolbarItem[];
+    hiddenOnDisabled: boolean;
+}, {}, string, {}> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: {
+        item: ToolbarItem;
+    }) => any>>;
+})> & Record<string, any>;
+export default XToolbar;
+export * from './toolbar';

package/types/components/toolbar/toolbar.d.ts

@@ -0,0 +1,45 @@
+import { PropType, ExtractPropTypes } from 'vue';
+import { Emits, ToolProps, UnReadOnly, ToolMenu, ToolValue } from '../..';
+import { ButtonProps, ButtonType } from 'element-plus';
+export type ToolbarButton = Omit<Partial<UnReadOnly<ButtonProps>>, 'icon' | 'disabled' | 'size'>;
+export type ToolbarButtonGroup = {
+    type?: ButtonType;
+    size?: 'default' | 'small' | 'large';
+};
+export type ToolbarButtonChildren = ToolbarButton & Pick<ToolProps, 'label' | 'value' | 'icon'>;
+export interface ToolbarItem extends ToolProps, ToolbarButton {
+    children?: ToolbarButtonChildren[];
+    slot?: string;
+    divided?: boolean;
+}
+/**
+ * 定义组件属性参数
+ */
+export declare const toolbarProps: {
+    button: {
+        type: PropType<ToolbarButtonGroup>;
+    };
+    items: {
+        type: PropType<ToolbarItem[]>;
+        default: () => never[];
+    };
+    hiddenOnDisabled: {
+        type: BooleanConstructor;
+    };
+};
+/**
+ * 定义组件事件
+ */
+export declare const toolbarEmits: {
+    click: (value?: ToolValue) => boolean;
+    command: (value: ToolValue, menu: ToolMenu) => boolean;
+    close: (value: ToolValue, menu: ToolMenu) => boolean;
+};
+/**
+ * 组件属性类型
+ */
+export type ToolbarProps = Partial<ExtractPropTypes<typeof toolbarProps>>;
+/**
+ * 组件事件类型
+ */
+export type ToolbarEmits = Emits<typeof toolbarEmits>;

package/types/components/wrapper/Wrapper.vue.d.ts

@@ -0,0 +1,268 @@
+import { BlockDirection, BlockWrap, BlockOverflow } from '../..';
+import { DefineComponent, PropType, ExtractPropTypes, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
+declare const _default: __VLS_WithTemplateSlots<DefineComponent<{
+    position: {
+        type: PropType<"bottom" | "top" | "none">;
+        default: string;
+    };
+    fixed: {
+        type: PropType<Partial<ExtractPropTypes<{
+            flex: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            width: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            height: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            direction: {
+                type: PropType<BlockDirection>;
+                default: string;
+            };
+            grow: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            shrink: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wrap: {
+                type: PropType<BlockWrap>;
+                default: string;
+            };
+            justify: {
+                type: StringConstructor;
+                default: string;
+            };
+            align: {
+                type: StringConstructor;
+                default: string;
+            };
+            border: {
+                type: BooleanConstructor;
+            };
+            radius: {
+                type: BooleanConstructor;
+            };
+            background: {
+                type: BooleanConstructor;
+            };
+            split: {
+                type: BooleanConstructor;
+            };
+            fit: {
+                type: BooleanConstructor;
+            };
+            overflow: {
+                type: PropType<BlockOverflow>;
+                default: string;
+            };
+            padding: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>>>;
+    };
+    body: {
+        type: PropType<Partial<ExtractPropTypes<{
+            flex: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            width: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            height: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            direction: {
+                type: PropType<BlockDirection>;
+                default: string;
+            };
+            grow: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            shrink: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wrap: {
+                type: PropType<BlockWrap>;
+                default: string;
+            };
+            justify: {
+                type: StringConstructor;
+                default: string;
+            };
+            align: {
+                type: StringConstructor;
+                default: string;
+            };
+            border: {
+                type: BooleanConstructor;
+            };
+            radius: {
+                type: BooleanConstructor;
+            };
+            background: {
+                type: BooleanConstructor;
+            };
+            split: {
+                type: BooleanConstructor;
+            };
+            fit: {
+                type: BooleanConstructor;
+            };
+            overflow: {
+                type: PropType<BlockOverflow>;
+                default: string;
+            };
+            padding: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>>>;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
+    position: {
+        type: PropType<"bottom" | "top" | "none">;
+        default: string;
+    };
+    fixed: {
+        type: PropType<Partial<ExtractPropTypes<{
+            flex: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            width: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            height: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            direction: {
+                type: PropType<BlockDirection>;
+                default: string;
+            };
+            grow: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            shrink: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wrap: {
+                type: PropType<BlockWrap>;
+                default: string;
+            };
+            justify: {
+                type: StringConstructor;
+                default: string;
+            };
+            align: {
+                type: StringConstructor;
+                default: string;
+            };
+            border: {
+                type: BooleanConstructor;
+            };
+            radius: {
+                type: BooleanConstructor;
+            };
+            background: {
+                type: BooleanConstructor;
+            };
+            split: {
+                type: BooleanConstructor;
+            };
+            fit: {
+                type: BooleanConstructor;
+            };
+            overflow: {
+                type: PropType<BlockOverflow>;
+                default: string;
+            };
+            padding: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>>>;
+    };
+    body: {
+        type: PropType<Partial<ExtractPropTypes<{
+            flex: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            width: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            height: {
+                type: (StringConstructor | NumberConstructor)[];
+            };
+            direction: {
+                type: PropType<BlockDirection>;
+                default: string;
+            };
+            grow: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            shrink: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            wrap: {
+                type: PropType<BlockWrap>;
+                default: string;
+            };
+            justify: {
+                type: StringConstructor;
+                default: string;
+            };
+            align: {
+                type: StringConstructor;
+                default: string;
+            };
+            border: {
+                type: BooleanConstructor;
+            };
+            radius: {
+                type: BooleanConstructor;
+            };
+            background: {
+                type: BooleanConstructor;
+            };
+            split: {
+                type: BooleanConstructor;
+            };
+            fit: {
+                type: BooleanConstructor;
+            };
+            overflow: {
+                type: PropType<BlockOverflow>;
+                default: string;
+            };
+            padding: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>>>;
+    };
+}>>, {
+    position: "bottom" | "top" | "none";
+}, {}>, {
+    default?(_: {}): any;
+    fixed?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};