@antsoo-lib/components 0.0.1

package/dist/src/vc-cascader/hooks/useSearchOptions.d.ts

@@ -0,0 +1,5 @@
+import { Ref, ComputedRef } from 'vue';
+import { DefaultOptionType, InternalFieldNames, ShowSearchType } from '../Cascader';
+export declare const SEARCH_MARK = "__rc_cascader_search_mark__";
+declare const _default: (search: Ref<string>, options: Ref<DefaultOptionType[]>, fieldNames: Ref<InternalFieldNames>, prefixCls: Ref<string>, config: Ref<ShowSearchType>, changeOnSelect: Ref<boolean>) => ComputedRef<DefaultOptionType[]>;
+export default _default;

package/dist/src/vc-cascader/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Cascader, SHOW_CHILD, SHOW_PARENT, internalCascaderProps as cascaderProps } from './Cascader';
+export type { BaseOptionType, CascaderProps, DefaultOptionType, FieldNames, ShowSearchType, } from './Cascader';
+export { cascaderProps, SHOW_CHILD, SHOW_PARENT };
+export default Cascader;

package/dist/src/vc-cascader/utils/commonUtil.d.ts

@@ -0,0 +1,10 @@
+import { DefaultOptionType, FieldNames, InternalFieldNames, SingleValueType } from '../Cascader';
+export declare const VALUE_SPLIT = "__RC_CASCADER_SPLIT__";
+export declare const SHOW_PARENT = "SHOW_PARENT";
+export declare const SHOW_CHILD = "SHOW_CHILD";
+export declare function toPathKey(value: SingleValueType): string;
+export declare function toPathKeys(value: SingleValueType[]): string[];
+export declare function toPathValueStr(pathKey: string): string[];
+export declare function fillFieldNames(fieldNames?: FieldNames): InternalFieldNames;
+export declare function isLeaf(option: DefaultOptionType, fieldNames: FieldNames): any;
+export declare function scrollIntoParentView(element: HTMLElement): void;

package/dist/src/vc-cascader/utils/treeUtil.d.ts

@@ -0,0 +1,9 @@
+import { Key } from '../../_util/type';
+import { DefaultOptionType, InternalFieldNames, ShowCheckedStrategy, SingleValueType } from '../Cascader';
+import { OptionsInfo } from '../hooks/useEntities';
+export declare function formatStrategyValues(pathKeys: Key[], keyPathEntities: OptionsInfo['pathKeyEntities'], showCheckedStrategy: ShowCheckedStrategy): Key[];
+export declare function toPathOptions(valueCells: SingleValueType, options: DefaultOptionType[], fieldNames: InternalFieldNames, stringMode?: boolean): {
+    value: SingleValueType[number];
+    index: number;
+    option: DefaultOptionType;
+}[];

package/dist/src/vc-dialog/Mask.d.ts

@@ -0,0 +1,15 @@
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    visible: BooleanConstructor;
+    motionName: StringConstructor;
+    maskProps: ObjectConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    visible: BooleanConstructor;
+    motionName: StringConstructor;
+    maskProps: ObjectConstructor;
+}>> & Readonly<{}>, {
+    visible: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-dialog/index.d.ts

@@ -0,0 +1,4 @@
+import { default as DialogWrap } from './DialogWrap';
+import { default as dialogProps } from './IDialogPropTypes';
+export { dialogProps };
+export default DialogWrap;

package/dist/src/vc-dialog/util.d.ts

@@ -0,0 +1,6 @@
+export declare function getMotionName(prefixCls: string, transitionName?: string, animationName?: string): string | undefined;
+export declare function getUUID(): number;
+export declare function offset(el: Element): {
+    left: number;
+    top: number;
+};

package/dist/src/vc-drawer/index.d.ts

@@ -0,0 +1,2 @@
+import { default as Drawer } from './src/DrawerWrapper';
+export default Drawer;

package/dist/src/vc-drawer/src/DrawerWrapper.d.ts

@@ -0,0 +1,163 @@
+import { DefineComponent, ExtractPropTypes, PropType, CSSProperties, TransitionProps, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VueTypeDef } from 'vue-types';
+import { IPlacement } from './IDrawerPropTypes';
+declare const DrawerWrapper: DefineComponent<ExtractPropTypes<{
+    forceRender: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    getContainer: VueTypeDef<any>;
+    prefixCls: StringConstructor;
+    width: VueTypeDef<string | number>;
+    height: VueTypeDef<string | number>;
+    style: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    class: StringConstructor;
+    rootClassName: StringConstructor;
+    rootStyle: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    placement: {
+        type: PropType<IPlacement>;
+    };
+    wrapperClassName: StringConstructor;
+    level: {
+        type: PropType<string | string[]>;
+    };
+    levelMove: {
+        type: PropType<(number | [number, number]) | ((e: {
+            target: HTMLElement;
+            open: boolean;
+        }) => number | [number, number])>;
+    };
+    duration: StringConstructor;
+    ease: StringConstructor;
+    showMask: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    maskStyle: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    afterVisibleChange: FunctionConstructor;
+    keyboard: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    contentWrapperStyle: {
+        type: PropType< CSSProperties[]>;
+        default: CSSProperties[];
+    };
+    autofocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    motion: {
+        type: PropType<(placement: IPlacement) => TransitionProps>;
+        default: (placement: IPlacement) => TransitionProps;
+    };
+    maskMotion: {
+        type: PropType<TransitionProps>;
+        default: TransitionProps;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, ("close" | "handleClick")[], "close" | "handleClick", PublicProps, Readonly< ExtractPropTypes<{
+    forceRender: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    getContainer: VueTypeDef<any>;
+    prefixCls: StringConstructor;
+    width: VueTypeDef<string | number>;
+    height: VueTypeDef<string | number>;
+    style: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    class: StringConstructor;
+    rootClassName: StringConstructor;
+    rootStyle: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    placement: {
+        type: PropType<IPlacement>;
+    };
+    wrapperClassName: StringConstructor;
+    level: {
+        type: PropType<string | string[]>;
+    };
+    levelMove: {
+        type: PropType<(number | [number, number]) | ((e: {
+            target: HTMLElement;
+            open: boolean;
+        }) => number | [number, number])>;
+    };
+    duration: StringConstructor;
+    ease: StringConstructor;
+    showMask: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    maskStyle: {
+        type: PropType<CSSProperties>;
+        default: CSSProperties;
+    };
+    afterVisibleChange: FunctionConstructor;
+    keyboard: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    contentWrapperStyle: {
+        type: PropType< CSSProperties[]>;
+        default: CSSProperties[];
+    };
+    autofocus: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    open: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    motion: {
+        type: PropType<(placement: IPlacement) => TransitionProps>;
+        default: (placement: IPlacement) => TransitionProps;
+    };
+    maskMotion: {
+        type: PropType<TransitionProps>;
+        default: TransitionProps;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+    onHandleClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    style: CSSProperties;
+    open: boolean;
+    motion: (placement: IPlacement) => TransitionProps;
+    autofocus: boolean;
+    forceRender: boolean;
+    maskClosable: boolean;
+    rootStyle: CSSProperties;
+    keyboard: boolean;
+    showMask: boolean;
+    maskStyle: CSSProperties;
+    contentWrapperStyle: CSSProperties[];
+    maskMotion: TransitionProps;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default DrawerWrapper;

package/dist/src/vc-drawer/src/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function dataToArray(vars: any): any[];
+export declare const transitionStr: string;
+export declare const transitionEndFun: string;
+export declare function addEventListener(target: HTMLElement, eventType: string, callback: (e: TouchEvent | Event) => void, options?: any): void;
+export declare function removeEventListener(target: HTMLElement, eventType: string, callback: (e: TouchEvent | Event) => void, options?: any): void;
+export declare function transformArguments(arg: any, cb: any): any[];
+export declare const isNumeric: (value: string | number | undefined) => boolean;
+export declare const windowIsUndefined: boolean;
+export declare const getTouchParentScroll: (root: HTMLElement, currentTarget: HTMLElement | Document | null, differX: number, differY: number) => boolean;

package/dist/src/vc-dropdown/index.d.ts

@@ -0,0 +1,2 @@
+import { default as Dropdown } from './Dropdown';
+export default Dropdown;

package/dist/src/vc-dropdown/placements.d.ts

@@ -0,0 +1,57 @@
+declare const placements: {
+    topLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    topCenter: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    topRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottomLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottomCenter: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottomRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+};
+export default placements;

package/dist/src/vc-image/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Image } from './src/Image';
+export * from './src/Image';
+export default Image;

package/dist/src/vc-image/src/PreviewGroup.d.ts

@@ -0,0 +1,79 @@
+import { ComputedRef, PropType, Ref, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, VNode, ComponentProvideOptions } from 'vue';
+import { ImagePreviewType } from './Image';
+import { PreviewProps } from './Preview';
+export interface PreviewGroupPreview extends Omit<ImagePreviewType, 'icons' | 'mask' | 'maskClassName'> {
+    /**
+     * If Preview the show img index
+     * @default 0
+     */
+    current?: number;
+}
+export interface GroupConsumerProps {
+    previewPrefixCls?: string;
+    icons?: PreviewProps['icons'];
+    preview?: boolean | PreviewGroupPreview;
+}
+export interface GroupConsumerValue extends GroupConsumerProps {
+    isPreviewGroup?: Ref<boolean | undefined>;
+    previewUrls: ComputedRef<Map<number, string>>;
+    setPreviewUrls: (id: number, url: string, canPreview?: boolean) => void;
+    current: Ref<number>;
+    setCurrent: (current: number) => void;
+    setShowPreview: (isShowPreview: boolean) => void;
+    setMousePosition: (mousePosition: null | {
+        x: number;
+        y: number;
+    }) => void;
+    registerImage: (id: number, url: string, canPreview?: boolean) => () => void;
+    rootClassName?: string;
+}
+export declare const context: {
+    provide: (val: GroupConsumerValue) => void;
+    inject: () => GroupConsumerValue;
+};
+export declare const imageGroupProps: () => {
+    previewPrefixCls: StringConstructor;
+    preview: {
+        type: PropType<boolean | ImagePreviewType>;
+        default: boolean | ImagePreviewType;
+    };
+    icons: {
+        type: PropType<PreviewProps["icons"]>;
+        default: () => {};
+    };
+};
+declare const Group: DefineComponent<ExtractPropTypes<{
+    previewPrefixCls: StringConstructor;
+    preview: {
+        type: PropType<boolean | ImagePreviewType>;
+        default: boolean | ImagePreviewType;
+    };
+    icons: {
+        type: PropType<PreviewProps["icons"]>;
+        default: () => {};
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    previewPrefixCls: StringConstructor;
+    preview: {
+        type: PropType<boolean | ImagePreviewType>;
+        default: boolean | ImagePreviewType;
+    };
+    icons: {
+        type: PropType<PreviewProps["icons"]>;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    preview: boolean | ImagePreviewType;
+    icons: {
+        rotateLeft?: VNode;
+        rotateRight?: VNode;
+        zoomIn?: VNode;
+        zoomOut?: VNode;
+        close?: VNode;
+        left?: VNode;
+        right?: VNode;
+        flipX?: VNode;
+        flipY?: VNode;
+    } | undefined;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default Group;

package/dist/src/vc-image/src/getFixScaleEleTransPosition.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Fix positon x,y point when
+ *
+ * Ele width && height < client
+ * - Back origin
+ *
+ * - Ele width | height > clientWidth | clientHeight
+ * - left | top > 0 -> Back 0
+ * - left | top + width | height < clientWidth | clientHeight -> Back left | top + width | height === clientWidth | clientHeight
+ *
+ * Regardless of other
+ */
+export default function getFixScaleEleTransPosition(width: number, height: number, left: number, top: number): null | {
+    x: number;
+    y: number;
+};

package/dist/src/vc-image/src/hooks/useFrameSetState.d.ts

@@ -0,0 +1,3 @@
+type SetActionType<T> = Partial<T> | ((state: T) => Partial<T>);
+export default function useFrameSetState<T extends object>(initial: T): [Record<string, any>, (newState: SetActionType<T>) => void];
+export {};

package/dist/src/vc-input/utils/commonUtils.d.ts

@@ -0,0 +1,8 @@
+export declare function hasPrefixSuffix(propsAndSlots: any): number | boolean;
+export declare function hasAddon(propsAndSlots: any): number | boolean;
+export declare function fixControlledValue(value: string | number): string;
+export declare function resolveOnChange(target: HTMLInputElement, e: Event, onChange: Function, targetValue?: string): void;
+export interface InputFocusOptions extends FocusOptions {
+    cursor?: 'start' | 'end' | 'all';
+}
+export declare function triggerFocus(element?: HTMLInputElement | HTMLTextAreaElement, option?: InputFocusOptions): void;

package/dist/src/vc-input/utils/types.d.ts

@@ -0,0 +1,2 @@
+/** https://github.com/Microsoft/TypeScript/issues/29729 */
+export type LiteralUnion<T extends U, U> = T | (U & {});

package/dist/src/vc-mentions/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Mentions } from './src/Mentions';
+import { default as Option } from './src/Option';
+export { Option };
+export default Mentions;

package/dist/src/vc-mentions/src/DropdownMenu.d.ts

@@ -0,0 +1,18 @@
+import { PropType, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { OptionProps } from './Option';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    options: {
+        type: PropType<OptionProps[]>;
+        default: () => never[];
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    options: {
+        type: PropType<OptionProps[]>;
+        default: () => never[];
+    };
+}>> & Readonly<{}>, {
+    options: OptionProps[];
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-mentions/src/KeywordTrigger.d.ts

@@ -0,0 +1,46 @@
+import { PropType, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { OptionProps } from './Option';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    options: {
+        type: PropType<OptionProps[]>;
+        default: () => never[];
+    };
+    prefixCls: StringConstructor;
+    placement: StringConstructor;
+    visible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    transitionName: StringConstructor;
+    getPopupContainer: FunctionConstructor;
+    direction: StringConstructor;
+    dropdownClassName: StringConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    options: {
+        type: PropType<OptionProps[]>;
+        default: () => never[];
+    };
+    prefixCls: StringConstructor;
+    placement: StringConstructor;
+    visible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    transitionName: StringConstructor;
+    getPopupContainer: FunctionConstructor;
+    direction: StringConstructor;
+    dropdownClassName: StringConstructor;
+}>> & Readonly<{}>, {
+    visible: boolean;
+    loading: boolean;
+    options: OptionProps[];
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-mentions/src/MentionsContext.d.ts

@@ -0,0 +1,12 @@
+import { InjectionKey, Ref } from 'vue';
+import { OptionProps } from './Option';
+export interface MentionsContext {
+    activeIndex: Ref<number>;
+    setActiveIndex?: (index: number) => void;
+    selectOption?: (option: OptionProps) => void;
+    onFocus?: EventListener;
+    onBlur?: EventListener;
+    loading?: Ref<boolean>;
+}
+declare const MentionsContextKey: InjectionKey<MentionsContext>;
+export default MentionsContextKey;

package/dist/src/vc-mentions/src/Option.d.ts

@@ -0,0 +1,68 @@
+import { ExtractPropTypes, HTMLAttributes, PropType, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VueNode } from '../../_util/type';
+export declare const baseOptionsProps: {
+    value: StringConstructor;
+    disabled: BooleanConstructor;
+    payload: {
+        type: PropType<Record<string, any>>;
+        default: Record<string, any>;
+    };
+};
+export declare const optionProps: {
+    label: {
+        default: VueNode | ((o: BaseOptionsProps) => VueNode);
+        type: PropType<VueNode | ((o: BaseOptionsProps) => VueNode)>;
+    };
+    value: StringConstructor;
+    disabled: BooleanConstructor;
+    payload: {
+        type: PropType<Record<string, any>>;
+        default: Record<string, any>;
+    };
+};
+export type BaseOptionsProps = Partial<ExtractPropTypes<typeof baseOptionsProps>> & Partial<HTMLAttributes>;
+export type OptionProps = Partial<ExtractPropTypes<typeof optionProps>> & Partial<HTMLAttributes>;
+export declare const optionOptions: {
+    name: string;
+    props: {
+        label: {
+            default: VueNode | ((o: BaseOptionsProps) => VueNode);
+            type: PropType<VueNode | ((o: BaseOptionsProps) => VueNode)>;
+        };
+        value: StringConstructor;
+        disabled: BooleanConstructor;
+        payload: {
+            type: PropType<Record<string, any>>;
+            default: Record<string, any>;
+        };
+    };
+    render(_props: any, { slots }: any): any;
+};
+declare const _default: DefineComponent<ExtractPropTypes<{
+    label: {
+        default: VueNode | ((o: BaseOptionsProps) => VueNode);
+        type: PropType<VueNode | ((o: BaseOptionsProps) => VueNode)>;
+    };
+    value: StringConstructor;
+    disabled: BooleanConstructor;
+    payload: {
+        type: PropType<Record<string, any>>;
+        default: Record<string, any>;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<{
+    label: {
+        default: VueNode | ((o: BaseOptionsProps) => VueNode);
+        type: PropType<VueNode | ((o: BaseOptionsProps) => VueNode)>;
+    };
+    value: StringConstructor;
+    disabled: BooleanConstructor;
+    payload: {
+        type: PropType<Record<string, any>>;
+        default: Record<string, any>;
+    };
+}>> & Readonly<{}>, {
+    label: VueNode | ((o: BaseOptionsProps) => VueNode);
+    disabled: boolean;
+    payload: Record<string, any>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-mentions/src/util.d.ts

@@ -0,0 +1,35 @@
+import { MentionsProps } from './Mentions';
+import { OptionProps } from './Option';
+/**
+ * Cut input selection into 2 part and return text before selection start
+ */
+export declare function getBeforeSelectionText(input: HTMLTextAreaElement): string;
+interface MeasureIndex {
+    location: number;
+    prefix: string;
+}
+/**
+ * Find the last match prefix index
+ */
+export declare function getLastMeasureIndex(text: string, prefix?: string | string[]): MeasureIndex;
+interface MeasureConfig {
+    measureLocation: number;
+    prefix: string;
+    targetText: string;
+    selectionStart: number;
+    split: string;
+}
+/**
+ * Paint targetText into current text:
+ *  text: little@litest
+ *  targetText: light
+ *  => little @light test
+ */
+export declare function replaceWithMeasure(text: string, measureConfig: MeasureConfig): {
+    text: string;
+    selectionLocation: number;
+};
+export declare function setInputSelection(input: HTMLTextAreaElement, location: number): void;
+export declare function validateSearch(text: string, props: MentionsProps): boolean;
+export declare function filterOption(input: string, { value }: OptionProps): boolean;
+export {};

package/dist/src/vc-notification/HookNotification.d.ts

@@ -0,0 +1,56 @@
+import { CSSProperties, DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { CSSMotionProps } from '../_util/transition';
+import { Key, VueNode } from '../_util/type';
+import { NoticeProps } from './Notice';
+export declare function getUuid(): string;
+export type Placement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight';
+export interface OpenConfig extends NoticeProps {
+    key: Key;
+    placement?: Placement;
+    content?: VueNode;
+    duration?: number | null;
+}
+export type Placements = Partial<Record<Placement, OpenConfig[]>>;
+export interface NoticeContent extends Omit<NoticeProps, 'prefixCls' | 'noticeKey' | 'onClose'> {
+    prefixCls?: string;
+    key?: Key;
+    updateMark?: string;
+    content?: any;
+    onClose?: () => void;
+    style?: CSSProperties;
+    class?: string;
+    placement?: Placement;
+}
+export type NoticeFunc = (noticeProps: NoticeContent) => void;
+export type HolderReadyCallback = (div: HTMLDivElement, noticeProps: NoticeProps & {
+    key: Key;
+}) => void;
+export interface NotificationInstance {
+    notice: NoticeFunc;
+    removeNotice: (key: Key) => void;
+    destroy: () => void;
+    add: (noticeProps: NoticeContent) => void;
+    component: Notification;
+}
+export interface HookNotificationProps {
+    prefixCls?: string;
+    transitionName?: string;
+    animation?: string | CSSMotionProps | ((placement?: Placement) => CSSMotionProps);
+    maxCount?: number;
+    closeIcon?: any;
+    hashId?: string;
+    remove: (key: Key) => void;
+    notices: NotificationState;
+    getStyles?: (placement?: Placement) => CSSProperties;
+    getClassName?: (placement?: Placement) => string;
+    onAllRemoved?: VoidFunction;
+    getContainer?: () => HTMLElement;
+}
+type NotificationState = {
+    notice: NoticeContent & {
+        userPassKey?: Key;
+    };
+    holderCallback?: HolderReadyCallback;
+}[];
+declare const Notification: DefineComponent<HookNotificationProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<HookNotificationProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default Notification;