naive-ui 2.40.4 → 2.41.1

package/es/_internal/selection/src/Selection.d.ts

@@ -1,4 +1,4 @@
-import type { FormValidationStatus } from '../../../form/src/interface';
+import type { FormValidationStatus } from '../../../form/src/public-types';
 import type { SelectBaseOption } from '../../../select/src/interface';
 import type { TagRef } from '../../../tag/src/Tag';
 import type { RenderLabel, RenderLabelImpl } from '../../select-menu/src/interface';

package/es/_mixins/use-form-item.d.ts

@@ -1,4 +1,4 @@
-import type { FormValidationStatus } from '../form/src/interface';
+import type { FormValidationStatus } from '../form/src/public-types';
 import { type ComputedRef, type Ref } from 'vue';
 type FormItemSize = 'small' | 'medium' | 'large';
 type AllowedSize = 'tiny' | 'small' | 'medium' | 'large' | 'huge' | number;

package/es/_utils/dom/download.d.ts

@@ -1 +1,2 @@
 export declare function download(url: string | null, name: string | undefined): void;
+export declare function publicDownload(url: string, name: string | undefined): void;

package/es/_utils/dom/download.mjs

@@ -8,4 +8,7 @@ export function download(url, name) {
   document.body.appendChild(a);
   a.click();
   document.body.removeChild(a);
+}
+export function publicDownload(url, name) {
+  download(url, name);
 }

package/es/_utils/index.d.ts

@@ -5,7 +5,7 @@ export * from './dom';
 export { isBrowser } from './env/is-browser';
 export { isJsdom } from './env/is-jsdom';
 export { eventEffectNotPerformed, markEventEffectPerformed } from './event';
-export { getTitleAttribute, largerSize, smallerSize, throwError, warn, warnOnce } from './naive';
+export { getTitleAttribute, isArrayShallowEqual, largerSize, smallerSize, throwError, warn, warnOnce } from './naive';
 export type { ExtractInternalPropTypes, ExtractPublicPropTypes, Mutable } from './naive';
-export { call, createDataKey, createInjectionKey, createRefSetter, flatten, getFirstSlotVNode, getSlot, getVNodeChildren, isNodeVShowFalse, isSlotEmpty, keep, keysOf, mergeEventHandlers, omit, render, resolveSlot, resolveSlotWithProps, resolveWrappedSlot, resolveWrappedSlotWithProps, Wrapper } from './vue';
+export { call, createDataKey, createInjectionKey, createRefSetter, flatten, getFirstSlotVNode, getFirstSlotVNodeWithTypedProps, getSlot, getVNodeChildren, isNodeVShowFalse, isSlotEmpty, keep, keysOf, mergeEventHandlers, omit, render, resolveSlot, resolveSlotWithTypedProps, resolveWrappedSlot, resolveWrappedSlotWithProps, Wrapper } from './vue';
 export type { MaybeArray } from './vue';

package/es/_utils/index.mjs

@@ -5,5 +5,5 @@ export * from "./dom/index.mjs";
 export { isBrowser } from "./env/is-browser.mjs";
 export { isJsdom } from "./env/is-jsdom.mjs";
 export { eventEffectNotPerformed, markEventEffectPerformed } from "./event/index.mjs";
-export { getTitleAttribute, largerSize, smallerSize, throwError, warn, warnOnce } from "./naive/index.mjs";
-export { call, createDataKey, createInjectionKey, createRefSetter, flatten, getFirstSlotVNode, getSlot, getVNodeChildren, isNodeVShowFalse, isSlotEmpty, keep, keysOf, mergeEventHandlers, omit, render, resolveSlot, resolveSlotWithProps, resolveWrappedSlot, resolveWrappedSlotWithProps, Wrapper } from "./vue/index.mjs";
+export { getTitleAttribute, isArrayShallowEqual, largerSize, smallerSize, throwError, warn, warnOnce } from "./naive/index.mjs";
+export { call, createDataKey, createInjectionKey, createRefSetter, flatten, getFirstSlotVNode, getFirstSlotVNodeWithTypedProps, getSlot, getVNodeChildren, isNodeVShowFalse, isSlotEmpty, keep, keysOf, mergeEventHandlers, omit, render, resolveSlot, resolveSlotWithTypedProps, resolveWrappedSlot, resolveWrappedSlotWithProps, Wrapper } from "./vue/index.mjs";

package/es/_utils/naive/index.d.ts

@@ -2,4 +2,5 @@ export { getTitleAttribute } from './attribute';
 export type { ExtractInternalPropTypes, ExtractPublicPropTypes } from './extract-public-props';
 export type { Mutable } from './mutable';
 export { largerSize, smallerSize } from './prop';
+export { isArrayShallowEqual } from './value';
 export { throwError, warn, warnOnce } from './warn';

package/es/_utils/naive/index.mjs

@@ -1,3 +1,4 @@
 export { getTitleAttribute } from "./attribute.mjs";
 export { largerSize, smallerSize } from "./prop.mjs";
+export { isArrayShallowEqual } from "./value.mjs";
 export { throwError, warn, warnOnce } from "./warn.mjs";

package/es/_utils/naive/value.d.ts

@@ -0,0 +1 @@
+export declare function isArrayShallowEqual<T extends Array<any>>(array1: T | null, array2: T | null): boolean;

package/es/_utils/naive/value.mjs

@@ -0,0 +1,13 @@
+export function isArrayShallowEqual(array1, array2) {
+  if (array1 === null && array2 === null) return true;
+  if (array1 === null || array2 === null) return false;
+  if (array1.length === array2.length) {
+    for (let i = 0; i < array1.length; ++i) {
+      if (array1[i] !== array2[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}

package/es/_utils/vue/get-first-slot-vnode.d.ts

@@ -1,2 +1,3 @@
 import type { Slots, VNode } from 'vue';
 export declare function getFirstSlotVNode(slots: Slots, slotName?: string, props?: unknown): VNode | null;
+export declare function getFirstSlotVNodeWithTypedProps<T>(slotName: string, slot: ((props: T) => VNode[]) | undefined, props: T): VNode | null;

package/es/_utils/vue/get-first-slot-vnode.mjs

@@ -14,4 +14,17 @@ export function getFirstSlotVNode(slots, slotName = 'default', props = undefined
     warn('getFirstSlotVNode', `slot[${slotName}] should have exactly one child`);
     return null;
   }
+}
+export function getFirstSlotVNodeWithTypedProps(slotName, slot, props) {
+  if (!slot) {
+    return null;
+  }
+  const slotContent = flatten(slot(props));
+  // vue will normalize the slot, so slot must be an array
+  if (slotContent.length === 1) {
+    return slotContent[0];
+  } else {
+    warn('getFirstSlotVNode', `slot[${slotName}] should have exactly one child`);
+    return null;
+  }
 }

package/es/_utils/vue/index.d.ts

@@ -4,7 +4,7 @@ export { createDataKey } from './create-data-key';
 export { createInjectionKey } from './create-injection-key';
 export { createRefSetter } from './create-ref-setter';
 export { flatten } from './flatten';
-export { getFirstSlotVNode } from './get-first-slot-vnode';
+export { getFirstSlotVNode, getFirstSlotVNodeWithTypedProps } from './get-first-slot-vnode';
 export { getSlot } from './get-slot';
 export { getVNodeChildren } from './get-v-node-children';
 export { isNodeVShowFalse } from './is-node-v-show-false';
@@ -13,5 +13,5 @@ export { keysOf } from './keysOf';
 export { mergeEventHandlers } from './merge-handlers';
 export { omit } from './omit';
 export { render } from './render';
-export { isSlotEmpty, resolveSlot, resolveSlotWithProps, resolveWrappedSlot, resolveWrappedSlotWithProps } from './resolve-slot';
+export { isSlotEmpty, resolveSlot, resolveSlotWithTypedProps, resolveWrappedSlot, resolveWrappedSlotWithProps } from './resolve-slot';
 export { Wrapper } from './wrapper';

package/es/_utils/vue/index.mjs

@@ -3,7 +3,7 @@ export { createDataKey } from "./create-data-key.mjs";
 export { createInjectionKey } from "./create-injection-key.mjs";
 export { createRefSetter } from "./create-ref-setter.mjs";
 export { flatten } from "./flatten.mjs";
-export { getFirstSlotVNode } from "./get-first-slot-vnode.mjs";
+export { getFirstSlotVNode, getFirstSlotVNodeWithTypedProps } from "./get-first-slot-vnode.mjs";
 export { getSlot } from "./get-slot.mjs";
 export { getVNodeChildren } from "./get-v-node-children.mjs";
 export { isNodeVShowFalse } from "./is-node-v-show-false.mjs";
@@ -12,5 +12,5 @@ export { keysOf } from "./keysOf.mjs";
 export { mergeEventHandlers } from "./merge-handlers.mjs";
 export { omit } from "./omit.mjs";
 export { render } from "./render.mjs";
-export { isSlotEmpty, resolveSlot, resolveSlotWithProps, resolveWrappedSlot, resolveWrappedSlotWithProps } from "./resolve-slot.mjs";
+export { isSlotEmpty, resolveSlot, resolveSlotWithTypedProps, resolveWrappedSlot, resolveWrappedSlotWithProps } from "./resolve-slot.mjs";
 export { Wrapper } from "./wrapper.mjs";

package/es/_utils/vue/resolve-slot.d.ts

@@ -4,7 +4,7 @@ export declare function ensureValidVNode(vnodes: VNodeArrayChildren): VNodeArray
  * We shouldn't use the following functions with slot flags `_: 1, 2, 3`
  */
 export declare function resolveSlot(slot: Slot | undefined, fallback: () => VNodeArrayChildren): VNodeArrayChildren;
-export declare function resolveSlotWithProps<T>(slot: Slot | undefined, props: T, fallback: (props: T) => VNodeArrayChildren): VNodeArrayChildren;
+export declare function resolveSlotWithTypedProps<T>(slot: Slot<T> | undefined, props: T, fallback: (props: T) => VNodeArrayChildren): VNodeArrayChildren;
 /**
  * Resolve slot with wrapper if content exists, no fallback
  */

package/es/_utils/vue/resolve-slot.mjs

@@ -19,7 +19,7 @@ export function ensureValidVNode(vnodes) {
 export function resolveSlot(slot, fallback) {
   return slot && ensureValidVNode(slot()) || fallback();
 }
-export function resolveSlotWithProps(slot, props, fallback) {
+export function resolveSlotWithTypedProps(slot, props, fallback) {
   return slot && ensureValidVNode(slot(props)) || fallback(props);
 }
 /**

package/es/alert/index.d.ts

@@ -1,2 +1,2 @@
 export { alertProps, default as NAlert } from './src/Alert';
-export type { AlertProps } from './src/Alert';
+export type { AlertProps, AlertSlots } from './src/Alert';

package/es/alert/src/Alert.d.ts

@@ -1,5 +1,5 @@
 import type { ExtractPublicPropTypes } from '../../_utils';
-import { type PropType } from 'vue';
+import { type PropType, type SlotsType, type VNode } from 'vue';
 export declare const alertProps: {
     title: StringConstructor;
     showIcon: {
@@ -216,6 +216,11 @@ export declare const alertProps: {
     }, any>>>;
 };
 export type AlertProps = ExtractPublicPropTypes<typeof alertProps>;
+export interface AlertSlots {
+    default?: () => VNode[];
+    icon?: () => VNode[];
+    header?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     title: StringConstructor;
     showIcon: {
@@ -758,5 +763,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     bordered: boolean;
     showIcon: boolean;
     closable: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<AlertSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/alert/src/Alert.mjs

@@ -31,6 +31,7 @@ export default defineComponent({
   name: 'Alert',
   inheritAttrs: false,
   props: alertProps,
+  slots: Object,
   setup(props) {
     if (process.env.NODE_ENV !== 'production') {
       watchEffect(() => {

package/es/auto-complete/index.d.ts

@@ -1,3 +1,3 @@
 export { autoCompleteProps, default as NAutoComplete } from './src/AutoComplete';
-export type { AutoCompleteProps } from './src/AutoComplete';
-export type { AutoCompleteGroupOption, AutoCompleteInst, AutoCompleteOption } from './src/interface';
+export type { AutoCompleteProps, AutoCompleteSlots } from './src/AutoComplete';
+export type { AutoCompleteDefaultSlotProps, AutoCompleteGroupOption, AutoCompleteInst, AutoCompleteOption } from './src/interface';

package/es/auto-complete/src/AutoComplete.d.ts

@@ -1,9 +1,9 @@
 import type { RenderLabel, RenderOption } from '../../_internal/select-menu/src/interface';
-import type { FormValidationStatus } from '../../form/src/interface';
+import type { FormValidationStatus } from '../../form/src/public-types';
 import type { SelectBaseOption, SelectGroupOption, SelectIgnoredOption } from '../../select/src/interface';
-import type { AutoCompleteOptions, OnSelect, OnUpdateValue } from './interface';
+import type { AutoCompleteDefaultSlotProps, AutoCompleteOptions, OnSelect, OnUpdateValue } from './interface';
 import { type TreeNode } from 'treemate';
-import { type HTMLAttributes, type InputHTMLAttributes, type PropType } from 'vue';
+import { type HTMLAttributes, type InputHTMLAttributes, type PropType, type SlotsType, type VNode } from 'vue';
 import { type FollowerPlacement } from 'vueuc';
 import { type ExtractPublicPropTypes, type MaybeArray } from '../../_utils';
 export declare const autoCompleteProps: {
@@ -460,6 +460,12 @@ export declare const autoCompleteProps: {
     }>>>;
 };
 export type AutoCompleteProps = ExtractPublicPropTypes<typeof autoCompleteProps>;
+export interface AutoCompleteSlots {
+    default?: (options: AutoCompleteDefaultSlotProps) => VNode[];
+    empty?: () => VNode[];
+    prefix?: () => VNode[];
+    suffix?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly to: {
         type: PropType<HTMLElement | string | boolean>;
@@ -1636,5 +1642,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly blurAfterSelect: boolean;
     readonly clearAfterSelect: boolean;
     readonly showEmpty: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<AutoCompleteSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/auto-complete/src/AutoComplete.mjs

@@ -6,7 +6,7 @@ import { computed, defineComponent, h, ref, toRef, Transition, watchEffect, with
 import { VBinder, VFollower, VTarget } from 'vueuc';
 import { NInternalSelectMenu } from "../../_internal/index.mjs";
 import { useConfig, useFormItem, useTheme, useThemeClass } from "../../_mixins/index.mjs";
-import { call, getFirstSlotVNode, useAdjustedTo, warnOnce } from "../../_utils/index.mjs";
+import { call, getFirstSlotVNodeWithTypedProps, useAdjustedTo, warnOnce } from "../../_utils/index.mjs";
 import { NInput } from "../../input/index.mjs";
 import { createTmOptions } from "../../select/src/utils.mjs";
 import { autoCompleteLight } from "../styles/index.mjs";
@@ -67,6 +67,7 @@ export const autoCompleteProps = Object.assign(Object.assign({}, useTheme.props)
 export default defineComponent({
   name: 'AutoComplete',
   props: autoCompleteProps,
+  slots: Object,
   setup(props) {
     if (process.env.NODE_ENV !== 'production') {
       watchEffect(() => {
@@ -307,7 +308,7 @@ export default defineComponent({
         default: () => {
           const defaultSlot = this.$slots.default;
           if (defaultSlot) {
-            return getFirstSlotVNode(this.$slots, 'default', {
+            return getFirstSlotVNodeWithTypedProps('default', defaultSlot, {
               handleInput: this.handleInput,
               handleFocus: this.handleFocus,
               handleBlur: this.handleBlur,

package/es/auto-complete/src/interface.d.ts

@@ -12,3 +12,9 @@ export interface AutoCompleteInst {
     focus: () => void;
     blur: () => void;
 }
+export interface AutoCompleteDefaultSlotProps {
+    handleInput: (value: string) => void;
+    handleFocus: (e: FocusEvent) => void;
+    handleBlur: (e: FocusEvent) => void;
+    value: string | null;
+}

package/es/avatar/index.d.ts

@@ -1,2 +1,2 @@
 export { avatarProps, default as NAvatar } from './src/Avatar';
-export type { AvatarProps } from './src/Avatar';
+export type { AvatarProps, AvatarSlots } from './src/Avatar';

package/es/avatar/src/Avatar.d.ts

@@ -1,6 +1,6 @@
 import type { ExtractPublicPropTypes } from '../../_utils';
 import type { ObjectFit, Size } from './interface';
-import { type ImgHTMLAttributes, type PropType, type VNodeChild } from 'vue';
+import { type ImgHTMLAttributes, type PropType, type SlotsType, type VNode, type VNodeChild } from 'vue';
 import { type IntersectionObserverOptions } from '../../image/src/utils';
 export declare const avatarProps: {
     readonly size: PropType<Size>;
@@ -69,6 +69,11 @@ export declare const avatarProps: {
     }, any>>>;
 };
 export type AvatarProps = ExtractPublicPropTypes<typeof avatarProps>;
+export interface AvatarSlots {
+    default?: () => VNode[];
+    placeholder?: () => VNode[];
+    fallback?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly size: PropType<Size>;
     readonly src: StringConstructor;
@@ -227,5 +232,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly circle: boolean;
     readonly lazy: boolean;
     readonly bordered: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<AvatarSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/avatar/src/Avatar.mjs

@@ -38,6 +38,7 @@ export const avatarProps = Object.assign(Object.assign({}, useTheme.props), {
 export default defineComponent({
   name: 'Avatar',
   props: avatarProps,
+  slots: Object,
   setup(props) {
     const {
       mergedClsPrefixRef,

package/es/avatar-group/index.d.ts

@@ -1,2 +1,3 @@
 export { avatarGroupProps, default as NAvatarGroup } from './src/AvatarGroup';
-export type { AvatarGroupOption, AvatarGroupProps } from './src/AvatarGroup';
+export type { AvatarGroupOption, AvatarGroupProps, AvatarGroupSlots } from './src/AvatarGroup';
+export type { AvatarGroupAvatarSlotProps, AvatarGroupRestSlotProps } from './src/interface';

package/es/avatar-group/src/AvatarGroup.d.ts

@@ -1,6 +1,7 @@
 import type { ExtractPublicPropTypes } from '../../_utils';
 import type { Size } from '../../avatar/src/interface';
-import { type CSSProperties, type PropType } from 'vue';
+import type { AvatarGroupAvatarSlotProps, AvatarGroupRestSlotProps } from './interface';
+import { type CSSProperties, type PropType, type SlotsType, type VNode } from 'vue';
 export interface AvatarGroupInjection {
     size?: Size | undefined;
 }
@@ -70,6 +71,11 @@ export declare const avatarGroupProps: {
     }>>>;
 };
 export type AvatarGroupProps = ExtractPublicPropTypes<typeof avatarGroupProps>;
+export interface AvatarGroupSlots {
+    avatar?: (props: AvatarGroupAvatarSlotProps) => VNode[];
+    rest?: (props: AvatarGroupRestSlotProps) => VNode[];
+    default?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly max: NumberConstructor;
     readonly maxStyle: PropType<CSSProperties | string>;
@@ -232,5 +238,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     readonly options: AvatarGroupOption[];
     readonly vertical: boolean;
     readonly expandOnHover: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<AvatarGroupSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/avatar-group/src/AvatarGroup.mjs

@@ -19,6 +19,7 @@ export const avatarGroupProps = Object.assign(Object.assign({}, useTheme.props),
 export default defineComponent({
   name: 'AvatarGroup',
   props: avatarGroupProps,
+  slots: Object,
   setup(props) {
     const {
       mergedClsPrefixRef,

package/es/avatar-group/src/interface.d.ts

@@ -0,0 +1,8 @@
+import type { AvatarGroupOption } from './AvatarGroup';
+export interface AvatarGroupAvatarSlotProps {
+    option: AvatarGroupOption;
+}
+export interface AvatarGroupRestSlotProps {
+    options: Array<AvatarGroupOption>;
+    rest: number;
+}

package/es/avatar-group/src/interface.mjs

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

package/es/breadcrumb/index.d.ts

@@ -1,4 +1,4 @@
 export { breadcrumbProps, default as NBreadcrumb } from './src/Breadcrumb';
 export type { BreadcrumbProps } from './src/Breadcrumb';
 export { breadcrumbItemProps, default as NBreadcrumbItem } from './src/BreadcrumbItem';
-export type { BreadcrumbItemProps } from './src/BreadcrumbItem';
+export type { BreadcrumbItemProps, BreadcrumbItemSlots } from './src/BreadcrumbItem';

package/es/breadcrumb/src/BreadcrumbItem.d.ts

@@ -1,4 +1,4 @@
-import { type ExtractPropTypes, type PropType } from 'vue';
+import { type ExtractPropTypes, type PropType, type SlotsType, type VNode } from 'vue';
 export declare const breadcrumbItemProps: {
     readonly separator: StringConstructor;
     readonly href: StringConstructor;
@@ -9,6 +9,10 @@ export declare const breadcrumbItemProps: {
     readonly onClick: PropType<(e: MouseEvent) => void>;
 };
 export type BreadcrumbItemProps = Partial<ExtractPropTypes<typeof breadcrumbItemProps>>;
+export interface BreadcrumbItemSlots {
+    default?: () => VNode[];
+    separator?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     readonly separator: StringConstructor;
     readonly href: StringConstructor;
@@ -27,5 +31,5 @@ declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
     readonly onClick: PropType<(e: MouseEvent) => void>;
 }>> & Readonly<{}>, {
     readonly clickable: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<BreadcrumbItemSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/breadcrumb/src/BreadcrumbItem.mjs

@@ -14,6 +14,7 @@ export const breadcrumbItemProps = {
 export default defineComponent({
   name: 'BreadcrumbItem',
   props: breadcrumbItemProps,
+  slots: Object,
   setup(props, {
     slots
   }) {

package/es/button/index.d.ts

@@ -1,2 +1,2 @@
 export { buttonProps, default as NButton, XButton as NxButton } from './src/Button';
-export type { ButtonProps } from './src/Button';
+export type { ButtonProps, ButtonSlots } from './src/Button';

package/es/button/src/Button.d.ts

@@ -1,7 +1,7 @@
 import type { BaseWaveRef } from '../../_internal';
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
 import type { Size, Type } from './interface';
-import { type ButtonHTMLAttributes, type ExtractPropTypes, type PropType, type VNodeChild } from 'vue';
+import { type ButtonHTMLAttributes, type ExtractPropTypes, type PropType, type SlotsType, type VNode, type VNodeChild } from 'vue';
 export declare const buttonProps: {
     readonly color: StringConstructor;
     readonly textColor: StringConstructor;
@@ -666,6 +666,10 @@ export declare const buttonProps: {
     }, any>>>;
 };
 export type ButtonProps = ExtractPublicPropTypes<typeof buttonProps>;
+export interface ButtonSlots {
+    default?: () => VNode[];
+    icon?: () => VNode[];
+}
 declare const Button: import("vue").DefineComponent<ExtractPropTypes<{
     readonly color: StringConstructor;
     readonly textColor: StringConstructor;
@@ -2069,7 +2073,7 @@ declare const Button: import("vue").DefineComponent<ExtractPropTypes<{
     readonly iconPlacement: "left" | "right";
     readonly attrType: "reset" | "submit" | "button";
     readonly nativeFocusBehavior: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<ButtonSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 type InternalButtonProps = ExtractPropTypes<typeof buttonProps>;
 type NativeButtonProps = Omit<ButtonHTMLAttributes, keyof InternalButtonProps>;
 type MergedProps = Partial<InternalButtonProps & NativeButtonProps>;

package/es/button/src/Button.mjs

@@ -64,6 +64,7 @@ export const buttonProps = Object.assign(Object.assign({}, useTheme.props), {
 const Button = defineComponent({
   name: 'Button',
   props: buttonProps,
+  slots: Object,
   setup(props) {
     if (process.env.NODE_ENV !== 'production') {
       watchEffect(() => {

package/es/calendar/src/Calendar.d.ts

@@ -1,6 +1,6 @@
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
-import type { DateItem, OnPanelChange, OnUpdateValue } from './interface';
-import { type PropType } from 'vue';
+import type { CalendarDefaultSlotProps, CalendarHeaderSlotProps, DateItem, OnPanelChange, OnUpdateValue } from './interface';
+import { type PropType, type SlotsType, type VNode } from 'vue';
 export declare const calendarProps: {
     readonly isDateDisabled: PropType<(date: number) => boolean | undefined>;
     readonly value: NumberConstructor;
@@ -694,6 +694,10 @@ export declare const calendarProps: {
     }>>>;
 };
 export type CalendarProps = ExtractPublicPropTypes<typeof calendarProps>;
+export interface CalendarSlots {
+    default?: (props: CalendarDefaultSlotProps) => VNode[];
+    header?: (props: CalendarHeaderSlotProps) => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     readonly isDateDisabled: PropType<(date: number) => boolean | undefined>;
     readonly value: NumberConstructor;
@@ -2413,5 +2417,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     }>>>;
 }>> & Readonly<{}>, {
     readonly defaultValue: number | null;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<CalendarSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/calendar/src/Calendar.mjs

@@ -4,7 +4,7 @@ import { computed, defineComponent, Fragment, h, ref, toRef } from 'vue';
 import { NBaseIcon } from "../../_internal/index.mjs";
 import { ChevronLeftIcon, ChevronRightIcon } from "../../_internal/icons/index.mjs";
 import { useConfig, useLocale, useTheme, useThemeClass } from "../../_mixins/index.mjs";
-import { call, resolveSlotWithProps } from "../../_utils/index.mjs";
+import { call, resolveSlotWithTypedProps } from "../../_utils/index.mjs";
 import { NButton } from "../../button/index.mjs";
 import { NButtonGroup } from "../../button-group/index.mjs";
 import { dateArray } from "../../date-picker/src/utils.mjs";
@@ -24,6 +24,7 @@ export const calendarProps = Object.assign(Object.assign({}, useTheme.props), {
 export default defineComponent({
   name: 'Calendar',
   props: calendarProps,
+  slots: Object,
   setup(props) {
     var _a;
     const {
@@ -194,7 +195,7 @@ export default defineComponent({
       class: `${mergedClsPrefix}-calendar-header`
     }, h("div", {
       class: `${mergedClsPrefix}-calendar-header__title`
-    }, resolveSlotWithProps($slots.header, {
+    }, resolveSlotWithTypedProps($slots.header, {
       year,
       month: calendarMonth
     }, () => {

package/es/calendar/src/interface.d.ts

@@ -8,3 +8,12 @@ export type OnPanelChange = (info: {
     year: number;
     month: number;
 }) => void;
+export interface CalendarDefaultSlotProps {
+    year: number;
+    month: number;
+    date: number;
+}
+export interface CalendarHeaderSlotProps {
+    year: number;
+    month: number;
+}

package/es/card/index.d.ts

@@ -1,2 +1,2 @@
 export { cardProps, default as NCard } from './src/Card';
-export type { CardProps, CardSegmented } from './src/Card';
+export type { CardProps, CardSegmented, CardSlots } from './src/Card';

package/es/card/src/Card.d.ts

@@ -1,5 +1,5 @@
 import type { ExtractPublicPropTypes, MaybeArray } from '../../_utils';
-import { type CSSProperties, type PropType, type VNodeChild } from 'vue';
+import { type CSSProperties, type PropType, type SlotsType, type VNode, type VNodeChild } from 'vue';
 export interface CardSegmented {
     content?: boolean | 'soft';
     footer?: boolean | 'soft';
@@ -192,6 +192,14 @@ export declare const cardProps: {
     }, any>>>;
 };
 export type CardProps = ExtractPublicPropTypes<typeof cardProps>;
+export interface CardSlots {
+    default?: () => VNode[];
+    cover?: () => VNode[];
+    header?: () => VNode[];
+    'header-extra'?: () => VNode[];
+    footer?: () => VNode[];
+    action?: () => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     title: PropType<string | (() => VNodeChild)>;
     contentClass: StringConstructor;
@@ -575,5 +583,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     hoverable: boolean;
     embedded: boolean;
     segmented: boolean | CardSegmented;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<CardSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/es/card/src/Card.mjs

@@ -49,6 +49,7 @@ export const cardProps = Object.assign(Object.assign({}, useTheme.props), cardBa
 export default defineComponent({
   name: 'Card',
   props: cardProps,
+  slots: Object,
   setup(props) {
     const handleCloseClick = () => {
       const {

package/es/carousel/index.d.ts

@@ -1,4 +1,4 @@
 export { carouselProps, default as NCarousel } from './src/Carousel';
-export type { CarouselProps } from './src/Carousel';
+export type { CarouselProps, CarouselSlots } from './src/Carousel';
 export { default as NCarouselItem } from './src/CarouselItem';
-export type { CarouselInst } from './src/interface';
+export type { CarouselArrowSlotProps, CarouselDotSlotProps, CarouselInst } from './src/interface';

package/es/carousel/src/Carousel.d.ts

@@ -1,6 +1,6 @@
-import type { CSSProperties, PropType, Ref, TransitionProps, VNode } from 'vue';
+import type { CSSProperties, PropType, Ref, SlotsType, TransitionProps, VNode } from 'vue';
 import type { ExtractPublicPropTypes } from '../../_utils';
-import type { ArrowScopedSlotProps, DotScopedSlotProps, Size } from './interface';
+import type { ArrowScopedSlotProps, CarouselArrowSlotProps, CarouselDotSlotProps, DotScopedSlotProps, Size } from './interface';
 declare const transitionProperties: readonly ["transitionDuration", "transitionTimingFunction"];
 type TransitionStyle = Partial<Pick<CSSProperties, (typeof transitionProperties)[number]>>;
 export declare const carouselProps: {
@@ -97,6 +97,11 @@ export declare const carouselProps: {
     }, any>>>;
 };
 export type CarouselProps = ExtractPublicPropTypes<typeof carouselProps>;
+export interface CarouselSlots {
+    default?: () => VNode[];
+    arrow?: (props: CarouselArrowSlotProps) => VNode[];
+    dots?: (props: CarouselDotSlotProps) => VNode[];
+}
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     defaultIndex: {
         type: NumberConstructor;
@@ -343,5 +348,5 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     transitionStyle: Partial<Pick<CSSProperties, "transitionDuration" | "transitionTimingFunction">>;
     touchable: boolean;
     mousewheel: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, SlotsType<CarouselSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;