vue-devui 1.2.0 → 1.2.1-alpha.0

package/types/notification/src/notification-service.d.ts

@@ -0,0 +1,4 @@
+import { NotificationOption } from './notification-types';
+export default class NotificationService {
+    static open(options: NotificationOption): void;
+}

package/types/notification/src/notification-types.d.ts

@@ -0,0 +1,35 @@
+import type { ExtractPropTypes, PropType, h } from 'vue';
+export declare type NotificationType = 'normal' | 'success' | 'error' | 'warning' | 'info';
+export interface Message {
+    type?: NotificationType;
+    title?: string;
+    content?: string | ((message: Message) => ReturnType<typeof h>);
+    duration?: number;
+}
+export declare const notificationProps: {
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: PropType<NotificationType>;
+        default: string;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onClose: {
+        type: PropType<() => void>;
+    };
+};
+export declare type EmitEventFn = (event: 'update:modelValue' | 'destroy', result?: unknown) => void;
+export declare type VoidFn = () => void;
+export declare type NotificationProps = ExtractPropTypes<typeof notificationProps>;
+export declare type NotificationOption = Partial<NotificationProps> & {
+    content?: string;
+};

package/types/notification/src/notification.d.ts

@@ -0,0 +1,51 @@
+import './notification.scss';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: import("vue").PropType<import("./notification-types").NotificationType>;
+        default: string;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onClose: {
+        type: import("vue").PropType<() => void>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "destroy")[], "update:modelValue" | "destroy", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: import("vue").PropType<import("./notification-types").NotificationType>;
+        default: string;
+    };
+    duration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    onClose: {
+        type: import("vue").PropType<() => void>;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onDestroy?: ((...args: any[]) => any) | undefined;
+}, {
+    type: import("./notification-types").NotificationType;
+    title: string;
+    duration: number;
+    modelValue: boolean;
+}>;
+export default _default;

package/types/notification/src/use-notification.d.ts

@@ -0,0 +1,11 @@
+import type { ComputedRef } from 'vue';
+import { NotificationProps, EmitEventFn, VoidFn } from './notification-types';
+export declare function useNotification(props: NotificationProps): {
+    classes: ComputedRef<Record<string, boolean>>;
+};
+export declare function useEvent(props: NotificationProps, emit: EmitEventFn): {
+    interrupt: VoidFn;
+    removeReset: VoidFn;
+    close: VoidFn;
+    handleDestroy: VoidFn;
+};

package/types/overlay/__tests__/overlay.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/overlay/index.d.ts

@@ -0,0 +1,13 @@
+import type { App } from 'vue';
+import { FixedOverlay } from './src/fixed-overlay';
+import { FlexibleOverlay } from './src/flexible-overlay';
+export * from './src/fixed-overlay/fixed-overlay-types';
+export * from './src/flexible-overlay/flexible-overlay-types';
+export { FlexibleOverlay, FixedOverlay };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/overlay/src/base-overlay.d.ts

@@ -0,0 +1,2 @@
+import './base-overlay.scss';
+export declare const CommonOverlay: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;

package/types/overlay/src/fixed-overlay/fixed-overlay-types.d.ts

@@ -0,0 +1,19 @@
+import type { ExtractPropTypes } from 'vue';
+export declare const fixedOverlayProps: {
+    readonly modelValue: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly lockScroll: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly closeOnClickOverlay: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+};
+export declare type FixedOverlayProps = ExtractPropTypes<typeof fixedOverlayProps>;
+export interface UseFixedOverlay {
+    onClick: (e: Event) => void;
+}

package/types/overlay/src/fixed-overlay/index.d.ts

@@ -0,0 +1,32 @@
+import './fixed-overlay.scss';
+export declare const FixedOverlay: import("vue").DefineComponent<{
+    readonly modelValue: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly lockScroll: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly closeOnClickOverlay: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, "click" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly lockScroll: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly closeOnClickOverlay: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+}>>, {
+    readonly modelValue: boolean;
+    readonly lockScroll: boolean;
+    readonly closeOnClickOverlay: boolean;
+}>;

package/types/overlay/src/fixed-overlay/use-fixed-overlay.d.ts

@@ -0,0 +1,3 @@
+import { SetupContext } from 'vue';
+import { FixedOverlayProps, UseFixedOverlay } from './fixed-overlay-types';
+export declare function useFixedOverlay(props: FixedOverlayProps, ctx: SetupContext): UseFixedOverlay;

package/types/overlay/src/flexible-overlay/flexible-overlay-types.d.ts

@@ -0,0 +1,61 @@
+import type { ExtractPropTypes, PropType, Ref } from 'vue';
+export declare type Placement = 'top' | 'right' | 'bottom' | 'left' | 'top-start' | 'top-end' | 'right-start' | 'right-end' | 'bottom-start' | 'bottom-end' | 'left-start' | 'left-end';
+export declare type Alignment = 'start' | 'end';
+export declare type OffsetOptions = {
+    mainAxis?: number;
+    crossAxis?: number;
+};
+export declare type Point = {
+    x?: number;
+    y?: number;
+};
+export declare type UseOverlayFn = {
+    arrowRef: Ref<HTMLElement | undefined>;
+    overlayRef: Ref<HTMLElement | undefined>;
+    updatePosition: () => void;
+};
+export declare type EmitEventFn = (event: 'positionChange' | 'update:modelValue', result?: unknown) => void;
+export interface Rect {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+}
+export declare const flexibleOverlayProps: {
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    origin: {
+        type: PropType<HTMLElement>;
+        require: boolean;
+    };
+    position: {
+        type: PropType<Placement[]>;
+        default: string[];
+    };
+    offset: {
+        type: PropType<number | OffsetOptions>;
+        default: number;
+    };
+    shiftOffset: {
+        type: NumberConstructor;
+    };
+    align: {
+        type: PropType<Alignment> | null;
+        default: null;
+    };
+    showArrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isArrowCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clickEventBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare type FlexibleOverlayProps = ExtractPropTypes<typeof flexibleOverlayProps>;

package/types/overlay/src/flexible-overlay/index.d.ts

@@ -0,0 +1,85 @@
+import './flexible-overlay.scss';
+export declare const FlexibleOverlay: import("vue").DefineComponent<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    origin: {
+        type: import("vue").PropType<HTMLElement>;
+        require: boolean;
+    };
+    position: {
+        type: import("vue").PropType<import("./flexible-overlay-types").Placement[]>;
+        default: string[];
+    };
+    offset: {
+        type: import("vue").PropType<number | import("./flexible-overlay-types").OffsetOptions>;
+        default: number;
+    };
+    shiftOffset: {
+        type: NumberConstructor;
+    };
+    align: {
+        type: import("vue").PropType<import("./flexible-overlay-types").Alignment> | null;
+        default: null;
+    };
+    showArrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isArrowCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clickEventBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => false | JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "positionChange")[], "update:modelValue" | "positionChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    origin: {
+        type: import("vue").PropType<HTMLElement>;
+        require: boolean;
+    };
+    position: {
+        type: import("vue").PropType<import("./flexible-overlay-types").Placement[]>;
+        default: string[];
+    };
+    offset: {
+        type: import("vue").PropType<number | import("./flexible-overlay-types").OffsetOptions>;
+        default: number;
+    };
+    shiftOffset: {
+        type: NumberConstructor;
+    };
+    align: {
+        type: import("vue").PropType<import("./flexible-overlay-types").Alignment> | null;
+        default: null;
+    };
+    showArrow: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isArrowCenter: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    clickEventBubble: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onPositionChange?: ((...args: any[]) => any) | undefined;
+}, {
+    offset: number | import("./flexible-overlay-types").OffsetOptions;
+    position: import("./flexible-overlay-types").Placement[];
+    align: import("./flexible-overlay-types").Alignment;
+    modelValue: boolean;
+    showArrow: boolean;
+    isArrowCenter: boolean;
+    clickEventBubble: boolean;
+}>;

package/types/overlay/src/flexible-overlay/use-flexible-overlay.d.ts

@@ -0,0 +1,2 @@
+import { FlexibleOverlayProps, UseOverlayFn, EmitEventFn } from './flexible-overlay-types';
+export declare function useOverlay(props: FlexibleOverlayProps, emit: EmitEventFn): UseOverlayFn;

package/types/overlay/src/flexible-overlay/utils.d.ts

@@ -0,0 +1 @@
+export declare function getScrollParent(element: HTMLElement): HTMLElement | (Window & typeof globalThis);

package/types/pagination/__tests__/pagination.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/pagination/index.d.ts

@@ -0,0 +1,11 @@
+import { App } from 'vue';
+import Pagination from './src/pagination';
+export * from './src/pagination-types';
+export { Pagination };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    install(app: App): void;
+};
+export default _default;

package/types/pagination/src/components/config-menu.d.ts

@@ -0,0 +1,15 @@
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    readonly currentPageSize: NumberConstructor;
+    readonly pageSizeChange: FunctionConstructor;
+    readonly pageSizeOptions: PropType<number[]>;
+}, {
+    paginationConfig: import("vue").Ref<null>;
+    isShowConfig: import("vue").Ref<boolean>;
+    closeConfigMenu: (e: Event) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly currentPageSize: NumberConstructor;
+    readonly pageSizeChange: FunctionConstructor;
+    readonly pageSizeOptions: PropType<number[]>;
+}>>, {}>;
+export default _default;

package/types/pagination/src/components/jump-page.d.ts

@@ -0,0 +1,34 @@
+import { PropType, ExtractPropTypes } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    goToText: StringConstructor;
+    size: {
+        type: PropType<"" | "sm" | "lg">;
+        default: string;
+    };
+    pageIndex: NumberConstructor;
+    showJumpButton: BooleanConstructor;
+    totalPages: NumberConstructor;
+    cursor: NumberConstructor;
+    onChangeCursorEmit: PropType<(v: number) => void>;
+}, {
+    inputNum: import("vue").Ref<number | undefined>;
+    jumpPageChange: (currentPage: number) => void;
+    jump: (e: KeyboardEvent | 'btn') => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "changeCursorEmit"[], "changeCursorEmit", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+    goToText: StringConstructor;
+    size: {
+        type: PropType<"" | "sm" | "lg">;
+        default: string;
+    };
+    pageIndex: NumberConstructor;
+    showJumpButton: BooleanConstructor;
+    totalPages: NumberConstructor;
+    cursor: NumberConstructor;
+    onChangeCursorEmit: PropType<(v: number) => void>;
+}>> & {
+    onChangeCursorEmit?: ((...args: any[]) => any) | undefined;
+}, {
+    size: "" | "sm" | "lg";
+    showJumpButton: boolean;
+}>;
+export default _default;

package/types/pagination/src/components/page-link-icons.d.ts

@@ -0,0 +1,2 @@
+export declare function PreLinkIcon(): JSX.Element;
+export declare function NextLinkIcon(): JSX.Element;

package/types/pagination/src/components/page-nums.d.ts

@@ -0,0 +1,40 @@
+import { PropType, ExtractPropTypes } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    readonly size: {
+        readonly type: PropType<"" | "sm" | "lg">;
+        readonly default: "";
+    };
+    readonly preLink: StringConstructor;
+    readonly nextLink: StringConstructor;
+    readonly lite: BooleanConstructor;
+    readonly cursor: NumberConstructor;
+    readonly maxItems: NumberConstructor;
+    readonly totalPages: NumberConstructor;
+    readonly onChangeCursorEmit: PropType<(v: number) => void>;
+    readonly showTruePageIndex: BooleanConstructor;
+}, {
+    showPageNum: import("vue").ComputedRef<number[]>;
+    changeCursor: (pageSize: number) => void;
+    prevChange: (page: number) => void;
+    nextChange: (page: number) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "changeCursorEmit"[], "changeCursorEmit", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+    readonly size: {
+        readonly type: PropType<"" | "sm" | "lg">;
+        readonly default: "";
+    };
+    readonly preLink: StringConstructor;
+    readonly nextLink: StringConstructor;
+    readonly lite: BooleanConstructor;
+    readonly cursor: NumberConstructor;
+    readonly maxItems: NumberConstructor;
+    readonly totalPages: NumberConstructor;
+    readonly onChangeCursorEmit: PropType<(v: number) => void>;
+    readonly showTruePageIndex: BooleanConstructor;
+}>> & {
+    onChangeCursorEmit?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly size: "" | "sm" | "lg";
+    readonly showTruePageIndex: boolean;
+    readonly lite: boolean;
+}>;
+export default _default;

package/types/pagination/src/components/page-size.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/types/pagination/src/pagination-types.d.ts

@@ -0,0 +1,119 @@
+import type { PropType, ExtractPropTypes, InjectionKey, Ref, WritableComputedRef } from 'vue';
+declare type AppendToBodyDirection = 'rightDown' | 'rightUp' | 'leftUp' | 'leftDown' | 'centerDown' | 'centerUp';
+interface ConnectedPosition {
+    originX: 'start' | 'center' | 'end';
+    originY: 'top' | 'center' | 'bottom';
+    overlayX: 'start' | 'center' | 'end';
+    overlayY: 'top' | 'center' | 'bottom';
+    weight?: number;
+    offsetX?: number;
+    offsetY?: number;
+    panelClass?: string | string[];
+}
+declare type Size = 'lg' | '' | 'sm';
+export declare const paginationProps: {
+    readonly pageSize: {
+        readonly type: NumberConstructor;
+        readonly default: 10;
+    };
+    readonly total: {
+        readonly type: NumberConstructor;
+        readonly default: 0;
+    };
+    readonly pageSizeOptions: {
+        readonly type: PropType<number[]>;
+        readonly default: () => number[];
+    };
+    readonly pageSizeDirection: {
+        readonly type: PropType<(AppendToBodyDirection | ConnectedPosition)[]>;
+        readonly default: () => string[];
+    };
+    readonly pageIndex: {
+        readonly type: NumberConstructor;
+        readonly default: 1;
+    };
+    readonly maxItems: {
+        readonly type: NumberConstructor;
+        readonly default: 10;
+    };
+    readonly preLink: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly nextLink: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly size: {
+        readonly type: PropType<Size>;
+        readonly default: "";
+    };
+    readonly canJumpPage: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly canChangePageSize: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly canViewTotal: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly totalItemText: {
+        readonly type: StringConstructor;
+    };
+    readonly goToText: {
+        readonly type: StringConstructor;
+    };
+    readonly showJumpButton: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly showTruePageIndex: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly lite: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly showPageSelector: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly haveConfigMenu: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly autoFixPageIndex: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly autoHide: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly 'onUpdate:pageIndex': {
+        readonly type: PropType<(v: number) => void>;
+    };
+    readonly 'onUpdate:pageSize': {
+        readonly type: PropType<(v: number) => void>;
+    };
+    readonly onPageIndexChange: {
+        readonly type: PropType<(v: number) => void>;
+    };
+    readonly onPageSizeChange: {
+        readonly type: PropType<(v: number) => void>;
+    };
+};
+export declare type PaginationProps = ExtractPropTypes<typeof paginationProps>;
+export interface IPagination {
+    size: Ref<Size>;
+    currentPageSize: WritableComputedRef<number>;
+    pageSizeOptions: Ref<number[]>;
+    pageSizeChange: (val: Record<string, string | number>) => void;
+    t: (path: string) => void;
+}
+export declare const paginationInjectionKey: InjectionKey<IPagination>;
+export {};

package/types/pagination/src/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 功能函数
+ */
+export declare const handlePages: (cursor: number, maxItems: number, totalPages: number) => number[];
+export declare function liteSelectOptions(total: number): Array<{
+    name: string;
+    value: number;
+}>;

package/types/panel/__tests__/panel.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/types/panel/index.d.ts

@@ -0,0 +1,18 @@
+import type { App } from 'vue';
+import Panel from './src/panel';
+import PanelHeader from './src/components/panel-header';
+import PanelBody from './src/components/panel-body';
+import PanelFooter from './src/components/panel-footer';
+export * from './src/panel-types';
+export { Panel, PanelHeader, PanelBody, PanelFooter };
+declare const _default: {
+    title: string;
+    category: string;
+    status: string;
+    deprecated: {
+        value: boolean;
+        reason: string;
+    };
+    install(app: App): void;
+};
+export default _default;

package/types/panel/src/components/panel-body.d.ts

@@ -0,0 +1,59 @@
+declare const _default: import("vue").DefineComponent<{
+    type: {
+        type: () => import("../panel-types").PanelType;
+        default: string;
+    };
+    cssClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    isCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    beforeToggle: {
+        type: () => (value: boolean, done?: (() => void) | undefined) => unknown;
+        default: null;
+    };
+    showAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasLeftPadding: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: () => import("../panel-types").PanelType;
+        default: string;
+    };
+    cssClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    isCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    beforeToggle: {
+        type: () => (value: boolean, done?: (() => void) | undefined) => unknown;
+        default: null;
+    };
+    showAnimation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasLeftPadding: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    type: import("../panel-types").PanelType;
+    cssClass: string;
+    showAnimation: boolean;
+    isCollapsed: boolean;
+    beforeToggle: (value: boolean, done?: (() => void) | undefined) => unknown;
+    hasLeftPadding: boolean;
+}>;
+export default _default;