import { ComputedRef, ExtractPropTypes } from 'vue';
import { ISharedRenderlessParamUtils } from './shared.type.js';

declare const drawerProps: {
    _constants: {
        type: ObjectConstructor;
        default: () => {
            SCROLL_LOCK_CLASS(mode: string): string;
            DEFAULT_WIDTH: string;
        };
    };
    visible: {
        type: BooleanConstructor;
        default: boolean;
    };
    customClass: (StringConstructor | ObjectConstructor | ArrayConstructor)[];
    placement: {
        type: StringConstructor;
        default: string;
    };
    width: {
        type: StringConstructor;
    };
    title: StringConstructor;
    showClose: {
        type: BooleanConstructor;
        default: boolean;
    };
    showHeader: {
        type: BooleanConstructor;
        default: boolean;
    };
    showFooter: {
        type: BooleanConstructor;
        default: boolean;
    };
    mask: {
        type: BooleanConstructor;
        default: boolean;
    };
    maskClosable: {
        type: BooleanConstructor;
        default: boolean;
    };
    dragable: BooleanConstructor;
    lockScroll: {
        type: BooleanConstructor;
        default: boolean;
    };
    flex: {
        type: BooleanConstructor;
        default: boolean;
    };
    zIndex: {
        type: NumberConstructor;
        default: number;
    };
    beforeClose: FunctionConstructor;
    tipsProps: ObjectConstructor;
    zsap_mode: StringConstructor;
    tiny_mode_root: BooleanConstructor;
    tiny_template: (FunctionConstructor | ObjectConstructor)[];
    tiny_renderless: FunctionConstructor;
    tiny_theme: StringConstructor;
    tiny_chart_theme: ObjectConstructor;
};

declare const close: ({ api }: {
    api: any;
}) => (force?: boolean) => void;
declare const watchVisible: ({ state }: {
    state: IDrawerState;
}) => (bool: any) => void;
declare const watchToggle: ({ emit }: {
    emit: ISharedRenderlessParamUtils['emit'];
}) => (bool: boolean) => void;
declare const confirm: ({ api }: {
    api: any;
}) => () => void;
declare const mousedown: ({ state, vm }: {
    vm: ISharedRenderlessParamUtils<IDrawerCT>['vm'];
    state: IDrawerState;
}) => (event: any) => void;
declare const mousemove: ({ state, props }: {
    state: IDrawerState;
    props: IDrawerProps;
}) => EventListenerOrEventListenerObject;
declare const mouseup: ({ state }: {
    state: IDrawerState;
}) => () => void;
declare const addDragEvent: ({ api, vm }: {
    api: IDrawerApi;
    vm: ISharedRenderlessParamUtils<IDrawerCT>['vm'];
}) => () => void;
declare const removeDragEvent: ({ api, vm }: {
    api: IDrawerApi;
    vm: ISharedRenderlessParamUtils<IDrawerCT>['vm'];
}) => () => void;
declare const showScrollbar: (lockScrollClass: any) => () => void;
declare const hideScrollbar: (lockScrollClass: any) => () => void;
declare const watchVisibleNotImmediate: ({ api, props }: {
    api: IDrawerApi;
    props: IDrawerProps;
}) => (visible: boolean) => void;

interface IDrawerState {
    toggle: boolean;
    width: number;
    dragEvent: {
        x: number;
        isDrag: boolean;
        offsetWidth: number;
    };
    computedWidth: ComputedRef<string>;
}
type IDrawerProps = ExtractPropTypes<typeof drawerProps>;
interface IDrawerApi {
    state: IDrawerState;
    confirm: ReturnType<typeof confirm>;
    close: ReturnType<typeof close>;
    mousemove: ReturnType<typeof mousemove>;
    mouseup: ReturnType<typeof mouseup>;
    mousedown: ReturnType<typeof mousedown>;
    addDragEvent: ReturnType<typeof addDragEvent>;
    removeDragEvent: ReturnType<typeof removeDragEvent>;
    watchVisible: ReturnType<typeof watchVisible>;
    watchToggle: ReturnType<typeof watchToggle>;
    showScrollbar: ReturnType<typeof showScrollbar>;
    hideScrollbar: ReturnType<typeof hideScrollbar>;
    watchVisibleNotImmediate: ReturnType<typeof watchVisibleNotImmediate>;
}
type IDrawerCT = ReturnType<typeof drawerProps._constants.default>;

export { IDrawerApi, IDrawerCT, IDrawerProps, IDrawerState };