@v-c/notification 1.0.0 → 2.0.0-rc.1

package/dist/Notifications.d.ts

@@ -1,11 +1,17 @@
-import { VueNode } from '@v-c/util/dist/type';
 import { CSSProperties, TransitionGroupProps } from 'vue';
-import { Key, OpenConfig, Placement, StackConfig } from './interface.ts';
+import { VueNode } from '@v-c/util/dist/type';
+import { Key, NotificationListConfig, Placement, StackConfig } from './interface';
+import { ComponentsType } from './Notification';
+import { NotificationClassNames, NotificationStyles } from './NotificationList';
 export interface NotificationsProps {
     prefixCls?: string;
     motion?: TransitionGroupProps | ((placement: Placement) => TransitionGroupProps);
     container?: HTMLElement | ShadowRoot;
     maxCount?: number;
+    pauseOnHover?: boolean;
+    classNames?: NotificationClassNames;
+    styles?: NotificationStyles;
+    components?: ComponentsType;
     className?: (placement: Placement) => string;
     style?: (placement: Placement) => CSSProperties;
     onAllRemoved?: VoidFunction;
@@ -16,7 +22,7 @@ export interface NotificationsProps {
     }) => VueNode;
 }
 export interface NotificationsRef {
-    open: (config: OpenConfig) => void;
+    open: (config: NotificationListConfig) => void;
     close: (key: Key) => void;
     destroy: () => void;
 }

package/dist/Notifications.js

@@ -1,26 +1,27 @@
-import NoticeList_default from "./NoticeList.js";
+import NotificationList from "./NotificationList/index.js";
 import { Teleport, createVNode, defineComponent, isVNode, mergeDefaults, shallowRef, watch } from "vue";
+//#region src/Notifications.tsx
 function _isSlot(s) {
 	return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !isVNode(s);
 }
 var defaults = { prefixCls: "vc-notification" };
-var Notifications_default = /* @__PURE__ */ defineComponent((props, { expose }) => {
+var Notifications = /* @__PURE__ */ defineComponent((props, { expose }) => {
 	const configList = shallowRef([]);
 	const onNoticeClose = (key) => {
 		const config = configList.value.find((item) => item.key === key);
 		const closable = config?.closable;
-		(closable && typeof closable === "object" ? closable : {}).onClose?.();
+		(closable && typeof closable === "object" ? closable : null)?.onClose?.();
 		config?.onClose?.();
 		configList.value = configList.value.filter((item) => item.key !== key);
 	};
 	expose({
 		open: (config) => {
 			const list = configList.value;
-			let clone = [...configList.value];
+			let clone = [...list];
 			const index = clone.findIndex((item) => item.key === config.key);
 			const innerConfig = { ...config };
 			if (index >= 0) {
-				innerConfig.times = (list[index]?.times || 0) + 1;
+				innerConfig.times = (list[index]?.times ?? 0) + 1;
 				clone[index] = innerConfig;
 			} else {
 				innerConfig.times = 0;
@@ -37,19 +38,16 @@ var Notifications_default = /* @__PURE__ */ defineComponent((props, { expose })
 	});
 	const placements = shallowRef({});
 	watch(configList, () => {
-		const nextPlacements = {};
+		const next = {};
 		configList.value.forEach((config) => {
-			const { placement = "topRight" } = config;
-			if (placement) {
-				nextPlacements[placement] = nextPlacements[placement] || [];
-				nextPlacements[placement].push(config);
-			}
+			const placement = config.placement ?? "topRight";
+			next[placement] = next[placement] || [];
+			next[placement].push(config);
 		});
-		Object.keys(placements.value).forEach((_placement) => {
-			const placement = _placement;
-			nextPlacements[placement] = nextPlacements[placement] || [];
+		Object.keys(placements.value).forEach((placement) => {
+			next[placement] = next[placement] || [];
 		});
-		placements.value = nextPlacements;
+		placements.value = next;
 	});
 	const onAllNoticeRemoved = (placement) => {
 		const clone = { ...placements.value };
@@ -67,20 +65,25 @@ var Notifications_default = /* @__PURE__ */ defineComponent((props, { expose })
 	return () => {
 		let _slot;
 		const { container } = props;
-		const prefixCls = props.prefixCls ?? defaults.prefixCls ?? "";
+		const prefixCls = props.prefixCls ?? defaults.prefixCls;
 		if (!container) return null;
-		return createVNode(Teleport, { "to": container }, _isSlot(_slot = Object.keys(placements.value).map((placement) => {
+		return createVNode(Teleport, { "to": container }, _isSlot(_slot = Object.keys(placements.value).map((rawPlacement) => {
+			const placement = rawPlacement;
 			const placementConfigList = placements.value[placement];
-			const list = createVNode(NoticeList_default, {
+			const list = createVNode(NotificationList, {
 				"key": placement,
 				"configList": placementConfigList,
 				"placement": placement,
 				"prefixCls": prefixCls,
-				"class": props.className?.(placement),
+				"pauseOnHover": props.pauseOnHover,
+				"classNames": props.classNames,
+				"styles": props.styles,
+				"components": props.components,
+				"className": props.className?.(placement),
 				"style": props.style?.(placement),
 				"motion": props.motion,
 				"stack": props.stack,
-				"onAllNoticeRemoved": () => onAllNoticeRemoved(placement),
+				"onAllRemoved": onAllNoticeRemoved,
 				"onNoticeClose": onNoticeClose
 			}, null);
 			return props.renderNotifications ? props.renderNotifications(list, {
@@ -110,6 +113,26 @@ var Notifications_default = /* @__PURE__ */ defineComponent((props, { expose })
 			required: false,
 			default: void 0
 		},
+		pauseOnHover: {
+			type: Boolean,
+			required: false,
+			default: void 0
+		},
+		classNames: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		styles: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		components: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
 		className: {
 			type: Function,
 			required: false,
@@ -137,4 +160,5 @@ var Notifications_default = /* @__PURE__ */ defineComponent((props, { expose })
 	}, defaults),
 	name: "Notifications"
 });
-export { Notifications_default as default };
+//#endregion
+export { Notifications as default };

package/dist/Progress.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties } from 'vue';
+export interface NotificationProgressProps {
+    className?: string;
+    style?: CSSProperties;
+    percent: number;
+}
+declare const Progress: import('vue').DefineSetupFnComponent<NotificationProgressProps, {}, {}, NotificationProgressProps & {}, import('vue').PublicProps>;
+export default Progress;

package/dist/Progress.js

@@ -0,0 +1,31 @@
+import { createVNode, defineComponent } from "vue";
+//#region src/Progress.tsx
+var Progress = /* @__PURE__ */ defineComponent((props) => {
+	return () => createVNode("progress", {
+		"class": props.className,
+		"max": "100",
+		"value": props.percent,
+		"style": props.style
+	}, null);
+}, {
+	props: {
+		className: {
+			type: String,
+			required: false,
+			default: void 0
+		},
+		style: {
+			type: Object,
+			required: false,
+			default: void 0
+		},
+		percent: {
+			type: Number,
+			required: true
+		}
+	},
+	name: "NotificationProgress",
+	inheritAttrs: false
+});
+//#endregion
+export { Progress as default };

package/dist/hooks/useClosable.d.ts

@@ -0,0 +1,17 @@
+import { AriaAttributes, ComputedRef } from 'vue';
+import { VueNode } from '@v-c/util/dist/type';
+export type ClosableConfig = {
+    closeIcon?: VueNode;
+    disabled?: boolean;
+    onClose?: VoidFunction;
+} & AriaAttributes & Record<`data-${string}`, unknown>;
+export type ClosableType = boolean | ClosableConfig | null | undefined;
+export interface ParsedClosableConfig extends ClosableConfig {
+    closeIcon: VueNode;
+    disabled: boolean;
+}
+/**
+ * Normalizes the closable option into a boolean flag, parsed config, and
+ * aria props for the close button. Mirrors rc-notification@2.0 useClosable.
+ */
+export default function useClosable(closable: ComputedRef<ClosableType>): [ComputedRef<boolean>, ComputedRef<ParsedClosableConfig>, ComputedRef<Record<string, unknown>>];

package/dist/hooks/useClosable.js

@@ -0,0 +1,34 @@
+import { computed } from "vue";
+import pickAttrs from "@v-c/util/dist/pickAttrs";
+//#region src/hooks/useClosable.ts
+/**
+* Normalizes the closable option into a boolean flag, parsed config, and
+* aria props for the close button. Mirrors rc-notification@2.0 useClosable.
+*/
+function useClosable(closable) {
+	const closableObj = computed(() => {
+		const value = closable.value;
+		if (value === false) return {
+			closeIcon: null,
+			disabled: true
+		};
+		if (typeof value === "object" && value !== null) return value;
+		return {};
+	});
+	const closableConfig = computed(() => {
+		const obj = closableObj.value;
+		return {
+			...obj,
+			closeIcon: "closeIcon" in obj ? obj.closeIcon : "×",
+			disabled: obj.disabled ?? false
+		};
+	});
+	const closableAriaProps = computed(() => pickAttrs(closableConfig.value, true));
+	return [
+		computed(() => !!closable.value),
+		closableConfig,
+		closableAriaProps
+	];
+}
+//#endregion
+export { useClosable as default };

package/dist/hooks/useListPosition/index.d.ts

@@ -0,0 +1,18 @@
+import { ComputedRef, Ref } from 'vue';
+import { Key } from '../../interface';
+export interface ListPositionStackConfig {
+    threshold?: number;
+    offset?: number;
+}
+/**
+ * Calculates each notification's position and the full list height.
+ * Mirrors rc-notification@2.0 useListPosition.
+ */
+export default function useListPosition(configList: ComputedRef<{
+    key: Key;
+}[]>, stack: ComputedRef<ListPositionStackConfig | undefined>, gap: Ref<number>): readonly [ComputedRef<{
+    notificationPosition: Map<string, number>;
+    totalHeight: number;
+    topNoticeHeight: number | undefined;
+    topNoticeWidth: number | undefined;
+}>, (key: string, node: HTMLDivElement | null) => void];

package/dist/hooks/useListPosition/index.js

@@ -0,0 +1,41 @@
+import useSizes from "./useSizes.js";
+import { computed } from "vue";
+//#region src/hooks/useListPosition/index.ts
+/**
+* Calculates each notification's position and the full list height.
+* Mirrors rc-notification@2.0 useListPosition.
+*/
+function useListPosition(configList, stack, gap) {
+	const [sizeMap, setNodeSize] = useSizes();
+	return [computed(() => {
+		let offsetY = 0;
+		let nextTotalHeight = 0;
+		const stackParams = stack.value;
+		const stackThreshold = stackParams?.threshold ?? 0;
+		const stackOffset = stackParams?.offset ?? 0;
+		const notificationPosition = /* @__PURE__ */ new Map();
+		let topNoticeHeight;
+		let topNoticeWidth;
+		configList.value.slice().reverse().forEach((config, index) => {
+			const key = String(config.key);
+			const height = sizeMap.value[key]?.height ?? 0;
+			const y = stackParams && index > 0 ? offsetY + stackOffset - height : offsetY;
+			notificationPosition.set(key, y);
+			if (index === 0) {
+				topNoticeHeight = height;
+				topNoticeWidth = sizeMap.value[key]?.width ?? 0;
+			}
+			if (!stackParams || index < stackThreshold) nextTotalHeight = Math.max(nextTotalHeight, y + height);
+			if (stackParams) offsetY = y + height;
+			else offsetY += height + gap.value;
+		});
+		return {
+			notificationPosition,
+			totalHeight: nextTotalHeight,
+			topNoticeHeight,
+			topNoticeWidth
+		};
+	}), setNodeSize];
+}
+//#endregion
+export { useListPosition as default };

package/dist/hooks/useListPosition/useSizes.d.ts

@@ -0,0 +1,10 @@
+export interface NodeSize {
+    width: number;
+    height: number;
+}
+export type NodeSizeMap = Record<string, NodeSize>;
+/**
+ * Stores measured node sizes by key and exposes a callback to update them.
+ * Mirrors rc-notification@2.0 useSizes.
+ */
+export default function useSizes(): readonly [import('vue').ShallowRef<NodeSizeMap, NodeSizeMap>, (key: string, node: HTMLDivElement | null) => void];

package/dist/hooks/useListPosition/useSizes.js

@@ -0,0 +1,31 @@
+import { shallowRef } from "vue";
+//#region src/hooks/useListPosition/useSizes.ts
+/**
+* Stores measured node sizes by key and exposes a callback to update them.
+* Mirrors rc-notification@2.0 useSizes.
+*/
+function useSizes() {
+	const sizeMap = shallowRef({});
+	const setNodeSize = (key, node) => {
+		if (!node) {
+			if (!(key in sizeMap.value)) return;
+			const next = { ...sizeMap.value };
+			delete next[key];
+			sizeMap.value = next;
+			return;
+		}
+		const nextSize = {
+			width: node.offsetWidth,
+			height: node.offsetHeight
+		};
+		const prev = sizeMap.value[key];
+		if (prev && prev.width === nextSize.width && prev.height === nextSize.height) return;
+		sizeMap.value = {
+			...sizeMap.value,
+			[key]: nextSize
+		};
+	};
+	return [sizeMap, setNodeSize];
+}
+//#endregion
+export { useSizes as default };

package/dist/hooks/useNoticeTimer.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef } from 'vue';
+/**
+ * Runs the notice auto-close timer and reports progress updates via rAF.
+ * Returns controls to pause and resume the timer. Mirrors rc-notification@2.0
+ * useNoticeTimer.
+ */
+export default function useNoticeTimer(duration: ComputedRef<number | false | null | undefined>, onClose: () => void, onUpdate: (percent: number) => void): [() => void, () => void];

package/dist/hooks/useNoticeTimer.js

@@ -0,0 +1,63 @@
+import { onScopeDispose, shallowRef, watch } from "vue";
+//#region src/hooks/useNoticeTimer.ts
+/**
+* Runs the notice auto-close timer and reports progress updates via rAF.
+* Returns controls to pause and resume the timer. Mirrors rc-notification@2.0
+* useNoticeTimer.
+*/
+function useNoticeTimer(duration, onClose, onUpdate) {
+	const durationMs = shallowRef(0);
+	const walking = shallowRef(false);
+	let passTime = 0;
+	let lastRafTime = null;
+	let rafId = null;
+	const syncPassTime = () => {
+		const now = Date.now();
+		if (lastRafTime !== null) passTime += now - lastRafTime;
+		lastRafTime = now;
+	};
+	const cancelStep = () => {
+		if (rafId !== null) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+	};
+	const onPause = () => {
+		syncPassTime();
+		walking.value = false;
+	};
+	const onResume = () => {
+		if (durationMs.value > 0) {
+			lastRafTime = Date.now();
+			walking.value = true;
+		} else onUpdate(0);
+	};
+	watch(duration, () => {
+		const next = typeof duration.value === "number" ? duration.value : 0;
+		durationMs.value = Math.max(next, 0) * 1e3;
+		passTime = 0;
+		walking.value = durationMs.value > 0;
+	}, { immediate: true });
+	watch(walking, (isWalking) => {
+		cancelStep();
+		if (!isWalking) return;
+		lastRafTime = Date.now();
+		const step = () => {
+			syncPassTime();
+			if (passTime >= durationMs.value) {
+				onUpdate(1);
+				onClose();
+				return;
+			}
+			onUpdate(Math.min(passTime / durationMs.value, 1));
+			rafId = requestAnimationFrame(step);
+		};
+		step();
+	}, { immediate: true });
+	onScopeDispose(() => {
+		cancelStep();
+	});
+	return [onResume, onPause];
+}
+//#endregion
+export { useNoticeTimer as default };

package/dist/hooks/useNotification.d.ts

@@ -1,22 +1,24 @@
-import { VueNode } from '@v-c/util/dist/type';
 import { CSSProperties, MaybeRef, TransitionGroupProps } from 'vue';
-import { Key, OpenConfig, Placement, StackConfig } from '../interface';
+import { VueNode } from '@v-c/util/dist/type';
+import { ClosableType, Key, NotificationListConfig, Placement, StackConfig } from '../interface';
+import { ComponentsType } from '../Notification';
+import { NotificationClassNames, NotificationStyles } from '../NotificationList';
 import { NotificationsProps } from '../Notifications';
-type OptionalConfig = Partial<OpenConfig>;
+type OptionalConfig = Partial<NotificationListConfig>;
 export interface NotificationConfig {
     prefixCls?: string;
     /** Customize container. It will repeat call which means you should return same container element. */
     getContainer?: () => HTMLElement | ShadowRoot;
     motion?: TransitionGroupProps | ((placement: Placement) => TransitionGroupProps);
-    closeIcon?: VueNode;
-    closable?: boolean | ({
-        closeIcon?: VueNode;
-        onClose?: VoidFunction;
-    } & Record<string, any>);
+    closable?: ClosableType;
     maxCount?: number;
     duration?: number | false | null;
     showProgress?: boolean;
     pauseOnHover?: boolean;
+    placement?: Placement;
+    classNames?: NotificationClassNames;
+    styles?: NotificationStyles;
+    components?: ComponentsType;
     /** @private. Config for notification holder style. Safe to remove if refactor */
     className?: (placement: Placement) => string;
     /** @private. Config for notification holder style. Safe to remove if refactor */

package/dist/hooks/useNotification.js

@@ -1,5 +1,6 @@
-import Notifications_default from "../Notifications.js";
+import Notifications from "../Notifications.js";
 import { computed, createVNode, onMounted, shallowRef, unref, watch } from "vue";
+//#region src/hooks/useNotification.tsx
 var defaultGetContainer = () => document.body;
 var uniqueKey = 0;
 function mergeConfig(...objList) {
@@ -17,18 +18,22 @@ function useNotification(rootConfig = {}) {
 	const container = shallowRef();
 	const notificationRef = shallowRef();
 	const shareConfig = computed(() => {
-		const { getContainer, motion, prefixCls, maxCount, className, style, onAllRemoved, stack, renderNotifications, ...restConfig } = configRef.value;
+		const { getContainer, motion, prefixCls, maxCount, className, style, onAllRemoved, stack, renderNotifications, pauseOnHover, classNames, styles, components, ...restConfig } = configRef.value;
 		return restConfig;
 	});
 	const resolveContainer = () => {
 		return (configRef.value.getContainer || defaultGetContainer)();
 	};
-	const contextHolder = () => createVNode(Notifications_default, {
+	const contextHolder = () => createVNode(Notifications, {
 		"container": container.value,
 		"ref": notificationRef,
 		"prefixCls": configRef.value.prefixCls,
 		"motion": configRef.value.motion,
 		"maxCount": configRef.value.maxCount,
+		"pauseOnHover": configRef.value.pauseOnHover,
+		"classNames": configRef.value.classNames,
+		"styles": configRef.value.styles,
+		"components": configRef.value.components,
 		"className": configRef.value.className,
 		"style": configRef.value.style,
 		"onAllRemoved": configRef.value.onAllRemoved,
@@ -80,9 +85,10 @@ function useNotification(rootConfig = {}) {
 					default: break;
 				}
 			});
-			taskQueue.value = taskQueue.value.filter((task) => !taskQueue.value.includes(task));
+			taskQueue.value = [];
 		}
 	});
 	return [api, contextHolder];
 }
+//#endregion
 export { useNotification as default };

package/dist/hooks/useStack.d.ts

@@ -2,5 +2,10 @@ import { ComputedRef, MaybeRef, ToRefs } from 'vue';
 import { StackConfig } from '../interface';
 type StackParams = Exclude<StackConfig, boolean>;
 type UseStack = (config?: MaybeRef<StackConfig | undefined>) => [ComputedRef<boolean>, ToRefs<StackParams>];
+/**
+ * Resolves the stack setting into an enabled flag and normalized stack params.
+ * Mirrors rc-notification@2.0 useStack. The `gap` config is no longer surfaced
+ * here — gap is now read from the list-content CSS `gap`/`row-gap`.
+ */
 declare const useStack: UseStack;
 export default useStack;

package/dist/hooks/useStack.js

@@ -1,22 +1,25 @@
 import { computed, reactive, toRefs, unref, watchEffect } from "vue";
+//#region src/hooks/useStack.ts
 var DEFAULT_OFFSET = 8;
 var DEFAULT_THRESHOLD = 3;
-var DEFAULT_GAP = 16;
+/**
+* Resolves the stack setting into an enabled flag and normalized stack params.
+* Mirrors rc-notification@2.0 useStack. The `gap` config is no longer surfaced
+* here — gap is now read from the list-content CSS `gap`/`row-gap`.
+*/
 var useStack = (config) => {
 	const result = reactive({
 		offset: DEFAULT_OFFSET,
-		threshold: DEFAULT_THRESHOLD,
-		gap: DEFAULT_GAP
+		threshold: DEFAULT_THRESHOLD
 	});
 	watchEffect(() => {
-		const _config = unref(config);
-		if (_config && typeof _config === "object") {
-			result.offset = _config.offset ?? DEFAULT_OFFSET;
-			result.threshold = _config.threshold ?? DEFAULT_THRESHOLD;
-			result.gap = _config.gap ?? DEFAULT_GAP;
+		const value = unref(config);
+		if (value && typeof value === "object") {
+			result.offset = value.offset ?? DEFAULT_OFFSET;
+			result.threshold = value.threshold ?? DEFAULT_THRESHOLD;
 		}
 	});
 	return [computed(() => !!unref(config)), toRefs(result)];
 };
-var useStack_default = useStack;
-export { useStack_default as default };
+//#endregion
+export { useStack as default };

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-import { NotificationAPI, NotificationConfig, default as useNotification } from './hooks/useNotification';
-import { default as Notice } from './Notice';
-import { useNotificationProvider } from './NotificationProvider';
-export { Notice, useNotification, useNotificationProvider };
-export type { NotificationAPI, NotificationConfig };
-export type { NoticeProps } from './Notice';
+import { default as useNotification, NotificationAPI, NotificationConfig } from './hooks/useNotification';
+import { default as Notification, ComponentsType, NotificationClassNames as NoticeClassNames, NotificationProps, NotificationStyles as NoticeStyles } from './Notification';
+import { default as NotificationList, NotificationClassNames, NotificationListProps, NotificationStyles, Placement } from './NotificationList';
+import { useNotificationContext, useNotificationProvider } from './NotificationProvider';
+import { default as Progress, NotificationProgressProps } from './Progress';
+import { Key, NotificationListConfig, StackConfig } from './interface';
+import { ClosableType, ParsedClosableConfig } from './hooks/useClosable';
+export { Notification, NotificationList, Progress, useNotification, useNotificationContext, useNotificationProvider, };
+export type { ClosableType, ComponentsType, Key, NoticeClassNames, NoticeStyles, NotificationAPI, NotificationClassNames, NotificationConfig, NotificationListConfig, NotificationListProps, NotificationProgressProps, NotificationProps, NotificationStyles, ParsedClosableConfig, Placement, StackConfig, };

package/dist/index.js

@@ -1,4 +1,6 @@
-import Notice_default from "./Notice.js";
-import { useNotificationProvider } from "./NotificationProvider.js";
+import Progress from "./Progress.js";
+import Notification from "./Notification.js";
+import { useNotificationContext, useNotificationProvider } from "./NotificationProvider.js";
+import NotificationList from "./NotificationList/index.js";
 import useNotification from "./hooks/useNotification.js";
-export { Notice_default as Notice, useNotification, useNotificationProvider };
+export { Notification, NotificationList, Progress, useNotification, useNotificationContext, useNotificationProvider };

package/dist/interface.d.ts

@@ -1,55 +1,30 @@
-import { VueNode } from '@v-c/util/dist/type';
-import { CSSProperties } from 'vue';
+import { ClosableType } from './hooks/useClosable';
+import { ComponentsType, NotificationProps } from './Notification';
 export type Placement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight';
-type NoticeSemanticProps = 'wrapper';
 export type Key = string | number;
-export interface NoticeConfig {
-    content?: VueNode;
-    duration?: number | false | null;
-    showProgress?: boolean;
-    pauseOnHover?: boolean;
-    closeIcon?: VueNode;
-    closable?: boolean | ({
-        closeIcon?: VueNode;
-        onClose?: VoidFunction;
-    } & Record<string, any>);
-    className?: string;
-    style?: CSSProperties;
-    classNames?: {
-        [key in NoticeSemanticProps]?: string;
-    };
-    styles?: {
-        [key in NoticeSemanticProps]?: CSSProperties;
-    };
-    /** @private Internal usage. Do not override in your code */
-    props?: Record<string, any>;
-    onClose?: VoidFunction;
-    onClick?: (event: Event) => void;
-}
-export interface OpenConfig extends NoticeConfig {
-    key: Key;
-    placement?: Placement;
-    content?: VueNode;
-    duration?: number | false | null;
-}
-export type InnerOpenConfig = OpenConfig & {
-    times?: number;
-};
-export type Placements = Partial<Record<Placement, OpenConfig[]>>;
 export type StackConfig = boolean | {
     /**
-     * When number is greater than threshold, notifications will be stacked together.
+     * When the notice count exceeds this threshold, notices will be stacked.
      * @default 3
      */
     threshold?: number;
     /**
-     * Offset when notifications are stacked together.
+     * Vertical offset applied between stacked notices.
      * @default 8
      */
     offset?: number;
-    /**
-     * Spacing between each notification when expanded.
-     */
-    gap?: number;
 };
-export {};
+/**
+ * Configuration accepted by the public `api.open` call.
+ * Mirrors rc-notification@2.0 NotificationListConfig.
+ */
+export interface NotificationListConfig extends Omit<NotificationProps, 'prefixCls'> {
+    key: Key;
+    placement?: Placement;
+    times?: number;
+}
+export type Placements = Partial<Record<Placement, NotificationListConfig[]>>;
+export type InnerOpenConfig = NotificationListConfig & {
+    times?: number;
+};
+export type { ClosableType, ComponentsType, NotificationProps, };