@vunk/plus 1.13.1 → 1.15.0

package/antx/sender/Sender.vue.d.ts

@@ -0,0 +1,48 @@
+import ClearButton from './components/ClearButton.vue';
+import LoadingButton from './components/LoadingButton.vue';
+import SendButton from './components/SendButton.vue';
+import SpeechButton from './components/SpeechButton/index.vue';
+import type { SenderProps } from './interface';
+import { type VNode } from 'vue';
+type __VLS_Slots = {
+    header?(): VNode;
+    prefix?(): VNode;
+    actions?(props: {
+        ori: VNode;
+        info: {
+            components: {
+                SendButton: typeof SendButton;
+                ClearButton: typeof ClearButton;
+                LoadingButton: typeof LoadingButton;
+                SpeechButton: typeof SpeechButton;
+            };
+        };
+    }): VNode;
+    footer?(props: {
+        info: {
+            components: {
+                SendButton: typeof SendButton;
+                ClearButton: typeof ClearButton;
+                LoadingButton: typeof LoadingButton;
+                SpeechButton: typeof SpeechButton;
+            };
+        };
+    }): VNode;
+};
+declare const __VLS_base: import("vue").DefineComponent<SenderProps, {
+    nativeElement: HTMLDivElement;
+    focus: (opt: any) => any;
+    blur: () => any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<SenderProps> & Readonly<{
+    "onUpdate:value"?: (value: string) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/antx/sender/SenderHeader.vue.d.ts

@@ -0,0 +1,13 @@
+import type { SenderHeaderProps } from './interface';
+type __VLS_Slots = {
+    default(props?: any): any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SenderHeaderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SenderHeaderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/antx/sender/StopLoading.vue.d.ts

@@ -0,0 +1,6 @@
+type __VLS_Props = {
+    className: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/sender/components/ActionButton/context.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef } from "vue";
+import type { ActionButtonContextProps } from "../../interface";
+export declare const globalActionButtonContextApi: import("vue").ShallowRef<ActionButtonContextProps, ActionButtonContextProps>;
+export declare const useActionButtonContextProvider: (value: ComputedRef<ActionButtonContextProps>) => void;
+export declare const useActionButtonContextInject: () => ComputedRef<ActionButtonContextProps>;
+export declare const ActionButtonContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<ActionButtonContextProps>;
+        default: ActionButtonContextProps;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<ActionButtonContextProps>;
+        default: ActionButtonContextProps;
+    };
+}>> & Readonly<{}>, {
+    value: ActionButtonContextProps;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default ActionButtonContextProvider;

package/antx/sender/components/ActionButton/index.vue.d.ts

@@ -0,0 +1,13 @@
+import type { ActionButtonProps } from '../../interface';
+type __VLS_Slots = {
+    default(): any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ActionButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ActionButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/antx/sender/components/ClearButton.vue.d.ts

@@ -0,0 +1,4 @@
+import type { AntdButtonProps } from '../interface';
+declare const __VLS_export: import("vue").DefineComponent<AntdButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AntdButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/sender/components/LoadingButton.vue.d.ts

@@ -0,0 +1,4 @@
+import type { AntdButtonProps } from '../interface';
+declare const __VLS_export: import("vue").DefineComponent<AntdButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AntdButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/sender/components/SendButton.vue.d.ts

@@ -0,0 +1,4 @@
+import type { AntdButtonProps } from '../interface';
+declare const __VLS_export: import("vue").DefineComponent<AntdButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AntdButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/sender/components/SpeechButton/RecordingIcon.vue.d.ts

@@ -0,0 +1,4 @@
+import type { RecordingIconProps } from '../../interface';
+declare const __VLS_export: import("vue").DefineComponent<RecordingIconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<RecordingIconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/sender/components/SpeechButton/index.vue.d.ts

@@ -0,0 +1,4 @@
+import type { AntdButtonProps } from '../../interface';
+declare const __VLS_export: import("vue").DefineComponent<AntdButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AntdButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/sender/context.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef } from "vue";
+import type { SenderHeaderContextProps } from "./interface";
+export declare const globalSenderHeaderContextApi: import("vue").ShallowRef<SenderHeaderContextProps, SenderHeaderContextProps>;
+export declare const useSenderHeaderContextProvider: (value: ComputedRef<SenderHeaderContextProps>) => void;
+export declare const useSenderHeaderContextInject: () => ComputedRef<SenderHeaderContextProps>;
+export declare const SenderHeaderContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<SenderHeaderContextProps>;
+        default: SenderHeaderContextProps;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<SenderHeaderContextProps>;
+        default: SenderHeaderContextProps;
+    };
+}>> & Readonly<{}>, {
+    value: SenderHeaderContextProps;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default SenderHeaderContextProvider;

package/antx/sender/index.d.ts

@@ -0,0 +1,82 @@
+export type { SenderProps } from './interface';
+declare const Sender: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").SenderProps> & Readonly<{
+        "onUpdate:value"?: (value: string) => any;
+    }>, {
+        nativeElement: HTMLDivElement;
+        focus: (opt: any) => any;
+        blur: () => any;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:value": (value: string) => any;
+    }, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").SenderProps> & Readonly<{
+        "onUpdate:value"?: (value: string) => any;
+    }>, {
+        nativeElement: HTMLDivElement;
+        focus: (opt: any) => any;
+        blur: () => any;
+    }, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").SenderProps> & Readonly<{
+    "onUpdate:value"?: (value: string) => any;
+}>, {
+    nativeElement: HTMLDivElement;
+    focus: (opt: any) => any;
+    blur: () => any;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (value: string) => any;
+}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        header?(): import("vue").VNode;
+        prefix?(): import("vue").VNode;
+        actions?(props: {
+            ori: import("vue").VNode;
+            info: {
+                components: {
+                    SendButton: typeof import("./components/SendButton.vue").default;
+                    ClearButton: typeof import("./components/ClearButton.vue").default;
+                    LoadingButton: typeof import("./components/LoadingButton.vue").default;
+                    SpeechButton: typeof import("./components/SpeechButton/index.vue").default;
+                };
+            };
+        }): import("vue").VNode;
+        footer?(props: {
+            info: {
+                components: {
+                    SendButton: typeof import("./components/SendButton.vue").default;
+                    ClearButton: typeof import("./components/ClearButton.vue").default;
+                    LoadingButton: typeof import("./components/LoadingButton.vue").default;
+                    SpeechButton: typeof import("./components/SpeechButton/index.vue").default;
+                };
+            };
+        }): import("vue").VNode;
+    };
+}) & {
+    Header: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").SenderHeaderProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("./interface").SenderHeaderProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("./interface").SenderHeaderProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default(props?: any): any;
+        };
+    });
+};
+export default Sender;
+export { Sender, };

package/antx/sender/interface.d.ts

@@ -0,0 +1,145 @@
+import type { ButtonProps, TextAreaProps } from "@vunk/plus/ant";
+import { Input } from "@vunk/plus/ant";
+import type { ConfigProviderProps } from "@vunk/plus/ant";
+import type { CSSProperties, VNode } from "vue";
+import type { AllowSpeech } from "./useSpeech";
+import type { AvoidValidation } from '../type-utility';
+import SendButton from "./components/SendButton.vue";
+import ClearButton from "./components/ClearButton.vue";
+import LoadingButton from "./components/LoadingButton.vue";
+import SpeechButton from "./components/SpeechButton/index.vue";
+export type SubmitType = 'enter' | 'shiftEnter' | false;
+export type KeyboardEventHandler = (e: KeyboardEvent) => void;
+export type ClipboardEventHandler = (e: ClipboardEvent) => void;
+export type ChangeEvent = Event & {
+    target: {
+        value?: string | undefined;
+    };
+};
+export interface SenderComponents {
+    input?: typeof Input.TextArea;
+}
+export type ActionsComponents = {
+    SendButton: typeof SendButton;
+    ClearButton: typeof ClearButton;
+    LoadingButton: typeof LoadingButton;
+    SpeechButton: typeof SpeechButton;
+};
+export type ActionsRender = (ori: VNode, info: {
+    components: ActionsComponents;
+}) => VNode;
+export type FooterRender = (info: {
+    components: ActionsComponents;
+}) => VNode;
+export interface SenderProps {
+    onKeyPress?: KeyboardEventHandler;
+    onFocus?: TextAreaProps['onFocus'];
+    onBlur?: TextAreaProps['onBlur'];
+    prefixCls?: string;
+    defaultValue?: string;
+    value?: string;
+    loading?: boolean;
+    placeholder?: TextAreaProps['placeholder'];
+    readOnly?: boolean;
+    submitType?: SubmitType;
+    disabled?: boolean;
+    sendDisabled?: boolean;
+    onSubmit?: (message: string) => void;
+    onChange?: (value: string, event?: ChangeEvent) => void;
+    onCancel?: VoidFunction;
+    onKeyDown?: KeyboardEventHandler;
+    onPaste?: ClipboardEventHandler;
+    onPasteFile?: (firstFile: File, files: FileList) => void;
+    components?: SenderComponents;
+    styles?: {
+        prefix?: CSSProperties;
+        input?: CSSProperties;
+        actions?: CSSProperties;
+        footer?: CSSProperties;
+    };
+    rootClassName?: string;
+    classNames?: {
+        prefix?: string;
+        input?: string;
+        actions?: string;
+        footer?: string;
+    };
+    style?: CSSProperties;
+    className?: string;
+    actions?: VNode | ActionsRender | false;
+    allowSpeech?: AvoidValidation<AllowSpeech>;
+    prefix?: VNode | (() => VNode);
+    footer?: VNode | FooterRender;
+    header?: VNode | (() => VNode);
+    autoSize?: AvoidValidation<boolean | {
+        minRows?: number;
+        maxRows?: number;
+    }>;
+}
+export interface InputFocusOptions extends FocusOptions {
+    cursor?: 'start' | 'end' | 'all';
+}
+export type SenderRef = {
+    nativeElement: HTMLDivElement;
+    focus: (options?: InputFocusOptions) => void;
+    blur: () => void;
+};
+export interface SenderHeaderContextProps {
+    prefixCls?: ConfigProviderProps['prefixCls'];
+}
+export type SemanticType = 'header' | 'content';
+export interface SenderHeaderProps {
+    forceRender?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    title?: VNode | string;
+    children?: VNode;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: Partial<Record<SemanticType, string>>;
+    styles?: Partial<Record<SemanticType, CSSProperties>>;
+    closable?: boolean;
+}
+export interface RecordingIconProps {
+    className?: string;
+    audioIcon?: ButtonProps['icon'];
+    audioDisabledIcon?: ButtonProps['icon'];
+    audioRecordingIcon?: ButtonProps['icon'];
+}
+export interface ActionButtonContextProps {
+    prefixCls?: ConfigProviderProps['prefixCls'];
+    onSend?: VoidFunction;
+    onSendDisabled?: boolean;
+    onClear?: VoidFunction;
+    onClearDisabled?: boolean;
+    onCancel?: VoidFunction;
+    onCancelDisabled?: boolean;
+    onSpeech?: VoidFunction;
+    onSpeechDisabled?: boolean;
+    speechRecording?: boolean;
+    disabled?: boolean;
+}
+export interface AntdButtonProps {
+    prefixCls?: ButtonProps['prefixCls'];
+    type?: ButtonProps['type'];
+    htmlType?: ButtonProps['htmlType'];
+    shape?: ButtonProps['shape'];
+    size?: ButtonProps['size'];
+    loading?: ButtonProps['loading'];
+    disabled?: ButtonProps['disabled'];
+    ghost?: ButtonProps['ghost'];
+    block?: ButtonProps['block'];
+    danger?: ButtonProps['danger'];
+    icon?: ButtonProps['icon'];
+    href?: ButtonProps['href'];
+    target?: ButtonProps['target'];
+    title?: ButtonProps['title'];
+    onClick?: ButtonProps['onClick'];
+    onMousedown?: ButtonProps['onMousedown'];
+    audioIcon?: ButtonProps['icon'] | VNode;
+    audioDisabledIcon?: ButtonProps['icon'] | VNode;
+    audioRecordingIcon?: ButtonProps['icon'] | VNode;
+}
+export interface ActionButtonProps extends AntdButtonProps {
+    action: 'onSend' | 'onClear' | 'onCancel' | 'onSpeech';
+}

package/antx/sender/style/header.d.ts

@@ -0,0 +1,4 @@
+import type { SenderToken } from '.';
+import type { GenerateStyle } from '../../theme/cssinjs-utils';
+declare const genSenderHeaderStyle: GenerateStyle<SenderToken>;
+export default genSenderHeaderStyle;

package/antx/sender/style/index.d.ts

@@ -0,0 +1,9 @@
+import type { FullToken, GetDefaultToken } from '../../theme/cssinjs-utils';
+export interface ComponentToken {
+}
+export interface SenderToken extends FullToken<'Sender'> {
+    SenderContentMaxWidth: number | string;
+}
+export declare const prepareComponentToken: GetDefaultToken<'Sender'>;
+declare const _default: (prefixCls: import("vue").MaybeRefOrGetter<string>, rootCls?: string) => readonly [(node: import("vue").VNode) => import("vue").VNode, import("vue").Ref<string, string>, string];
+export default _default;

package/antx/sender/useSpeech.d.ts

@@ -0,0 +1,16 @@
+import { ButtonProps } from "@vunk/plus/ant";
+import { type MaybeRefOrGetter, type ComputedRef, type Ref } from 'vue';
+export type ControlledSpeechConfig = {
+    recording?: boolean;
+    onRecordingChange?: (recording: boolean) => void;
+    audioIcon?: ButtonProps['icon'];
+    audioDisabledIcon?: ButtonProps['icon'];
+    audioRecordingIcon?: ButtonProps['icon'];
+};
+export type AllowSpeech = boolean | ControlledSpeechConfig;
+export type UseSpeechReturn = {
+    speechPermission: ComputedRef<boolean>;
+    triggerSpeech: (forceBreak: boolean) => void;
+    recording: Ref<boolean>;
+};
+export default function useSpeech(onSpeech: (transcript: string) => void, allowSpeech?: MaybeRefOrGetter<AllowSpeech>): UseSpeechReturn;

package/antx/theme/components.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentToken as AttachmentsToken } from '../attachments/style';
+import type { ComponentToken as SenderComponentToken } from '../sender/style';
+import type { ComponentToken as TransitionCollapseComponentToken } from '../transition-collapse/style';
+export interface ComponentTokenMap {
+    TransitionCollapse?: TransitionCollapseComponentToken;
+    Attachments?: AttachmentsToken;
+    Sender?: SenderComponentToken;
+}

package/antx/theme/cssinjs-utils.d.ts

@@ -0,0 +1,14 @@
+import type { GlobalToken as GlobalTokenTypeUtil, OverrideTokenMap as OverrideTokenTypeUtil, FullToken as FullTokenTypeUtil, GetDefaultToken as GetDefaultTokenTypeUtil, GenStyleFn as GenStyleFnTypeUtil, TokenMapKey } from '../_util/cssinjs-utils';
+import type { CSSInterpolation } from '../_util/cssinjs';
+import type { AliasToken } from '@vunk/plus/ant';
+import type { AnyObject } from '../_util/type';
+import type { ComponentTokenMap } from './components';
+export type { AliasToken, SeedToken } from '@vunk/plus/ant';
+/** Final token which contains the components level override */
+export type GlobalToken = GlobalTokenTypeUtil<ComponentTokenMap, AliasToken>;
+export type OverrideToken = OverrideTokenTypeUtil<ComponentTokenMap, AliasToken>;
+export type OverrideComponent = TokenMapKey<ComponentTokenMap>;
+export type FullToken<C extends TokenMapKey<ComponentTokenMap>> = FullTokenTypeUtil<ComponentTokenMap, AliasToken, C>;
+export type GetDefaultToken<C extends TokenMapKey<ComponentTokenMap>> = GetDefaultTokenTypeUtil<ComponentTokenMap, AliasToken, C>;
+export type GenStyleFn<C extends TokenMapKey<ComponentTokenMap>> = GenStyleFnTypeUtil<ComponentTokenMap, AliasToken, C>;
+export type GenerateStyle<ComponentToken extends AnyObject = AliasToken, ReturnType = CSSInterpolation> = (token: ComponentToken) => ReturnType;

package/antx/theme/genStyleUtils.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentTokenMap } from './components';
+import type { AliasToken } from './cssinjs-utils';
+export declare const genStyleHooks: <C extends keyof ComponentTokenMap>(component: C | [C, string], styleFn: import("../_util/cssinjs-utils").GenStyleFn<ComponentTokenMap, AliasToken, C>, getDefaultToken?: import("../_util/cssinjs-utils").GetDefaultToken<ComponentTokenMap, AliasToken, C>, options?: {
+    resetStyle?: boolean;
+    resetFont?: boolean;
+    deprecatedTokens?: [keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>, keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>][];
+    unitless?: Partial<Record<keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>, boolean>>;
+    clientOnly?: boolean;
+    order?: number;
+    injectStyle?: boolean;
+}) => (prefixCls: import("vue").MaybeRefOrGetter<string>, rootCls?: string) => readonly [(node: import("vue").VNode) => import("vue").VNode, import("vue").Ref<string, string>, string], genComponentStyleHook: <C extends keyof ComponentTokenMap>(componentName: C | [C, string], styleFn: import("../_util/cssinjs-utils").GenStyleFn<ComponentTokenMap, AliasToken, C>, getDefaultToken?: import("../_util/cssinjs-utils").GetDefaultToken<ComponentTokenMap, AliasToken, C>, options?: {
+    resetStyle?: boolean;
+    resetFont?: boolean;
+    deprecatedTokens?: [keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>, keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>][];
+    clientOnly?: boolean;
+    order?: number;
+    injectStyle?: boolean;
+    unitless?: Partial<Record<keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>, boolean>>;
+}) => (prefixCls: string, rootCls?: string) => import("../_util/cssinjs-utils/interface").UseComponentStyleResult, genSubStyleComponent: <C extends keyof ComponentTokenMap>(componentName: C | [C, string], styleFn: import("../_util/cssinjs-utils").GenStyleFn<ComponentTokenMap, AliasToken, C>, getDefaultToken?: import("../_util/cssinjs-utils").GetDefaultToken<ComponentTokenMap, AliasToken, C>, options?: {
+    resetStyle?: boolean;
+    resetFont?: boolean;
+    deprecatedTokens?: [keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>, keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>][];
+    clientOnly?: boolean;
+    order?: number;
+    injectStyle?: boolean;
+    unitless?: Partial<Record<keyof Exclude<import("../_util/cssinjs-utils").OverrideTokenMap<ComponentTokenMap, AliasToken>[C], undefined>, boolean>>;
+}) => any;

package/antx/theme/index.d.ts

@@ -0,0 +1,2 @@
+import { theme } from '@vunk/plus/ant';
+export { theme };

package/antx/theme/patch-antd.d.ts

@@ -0,0 +1,28 @@
+import type { MapToken } from "@vunk/plus/ant";
+import type { AliasToken, OverrideToken, SeedToken } from "./cssinjs-utils";
+import type { Theme } from "@vunk/plus/ant";
+export declare const ignore: {
+    [key in keyof AliasToken]?: boolean;
+};
+export declare const unitless: {
+    [key in keyof AliasToken]?: boolean;
+};
+export type ComponentsToken = {
+    [key in keyof OverrideToken]?: OverrideToken[key] & {
+        theme?: Theme<SeedToken, MapToken>;
+    };
+};
+export interface DesignTokenProviderProps {
+    token: Partial<AliasToken>;
+    theme?: Theme<SeedToken, MapToken>;
+    components?: ComponentsToken;
+    /** Just merge `token` & `override` at top to save perf */
+    override: {
+        override: Partial<AliasToken>;
+    } & ComponentsToken;
+    hashed?: string | boolean;
+    cssVar?: {
+        prefix?: string;
+        key?: string;
+    };
+}

package/antx/theme/useToken.d.ts

@@ -0,0 +1,19 @@
+import type { Theme } from '../_util/cssinjs';
+import type { DesignTokenProviderProps } from './patch-antd';
+import type { AliasToken, GlobalToken, SeedToken } from './cssinjs-utils';
+import { type Ref } from 'vue';
+export declare const getComputedToken: (originToken: SeedToken, overrideToken: DesignTokenProviderProps["components"] & {
+    override?: Partial<AliasToken>;
+}, theme: Theme<any, any>) => any;
+export declare function useInternalToken(): [
+    theme: Ref<Theme<SeedToken, AliasToken>>,
+    token: GlobalToken,
+    hashId: Ref<string>,
+    realToken: Ref<GlobalToken>,
+    cssVar?: DesignTokenProviderProps['cssVar']
+];
+export default function useToken(): {
+    theme: Ref<Theme<SeedToken, AliasToken>, Theme<SeedToken, AliasToken>>;
+    token: GlobalToken;
+    hashId: Ref<string, string>;
+};

package/antx/transition-collapse/TransitionCollapse.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    prefixCls?: string;
+};
+type __VLS_Slots = {
+    default?(props?: any): any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    prefixCls: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/antx/transition-collapse/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vue';
+import TransitionCollapse from './TransitionCollapse.vue';
+export { TransitionCollapse };
+export { genTransitionCollapseStyle } from './style';
+declare const _default: typeof TransitionCollapse & Plugin;
+export default _default;

package/antx/transition-collapse/style/index.d.ts

@@ -0,0 +1,6 @@
+import type { FullToken, GenerateStyle } from '../../theme/cssinjs-utils';
+export interface ComponentToken {
+}
+export interface TransitionCollapseToken extends FullToken<'TransitionCollapse'> {
+}
+export declare const genTransitionCollapseStyle: GenerateStyle<TransitionCollapseToken>;

package/antx/type-utility.d.ts

@@ -0,0 +1 @@
+export type AvoidValidation<T> = T;

package/antx/use-x-agent/index.d.ts

@@ -0,0 +1,4 @@
+import useXAgent, { XAgent } from './use-x-agent';
+export type { RequestFn, XAgentConfigPreset, XAgentConfigCustom, XAgentConfig } from './use-x-agent';
+export { useXAgent, XAgent };
+export default useXAgent;

package/antx/use-x-agent/use-x-agent.d.ts

@@ -0,0 +1,34 @@
+import type { SSEOutput, XStreamOptions } from '../x-stream';
+import type { AnyObject } from '../_util/type';
+import { type MaybeRefOrGetter } from 'vue';
+interface RequestFnInfo<Message> extends AnyObject {
+    messages?: Message[];
+    message?: Message;
+}
+export type RequestFn<Message, Input, Output> = (info: Input, callbacks: {
+    onUpdate: (chunk: Output) => void;
+    onSuccess: (chunk: Output[]) => void;
+    onError: (error: Error) => void;
+    onStream?: (abortController: AbortController) => void;
+}, transformStream?: XStreamOptions<Message>['transformStream']) => void;
+export interface XAgentConfigPreset {
+    baseURL: string;
+    key: string;
+    model: string;
+    dangerouslyApiKey: string;
+}
+export interface XAgentConfigCustom<Message, Input, Output> {
+    request?: RequestFn<Message, Input, Output>;
+}
+export type XAgentConfig<Message, Input, Output> = Partial<XAgentConfigPreset> & XAgentConfigCustom<Message, Input, Output>;
+/** This is a wrap class to avoid developer can get too much on origin object */
+export declare class XAgent<Message = string, Input = RequestFnInfo<Message>, Output = SSEOutput> {
+    config: XAgentConfig<Message, Input, Output>;
+    private requestingMap;
+    constructor(config: XAgentConfig<Message, Input, Output>);
+    private finishRequest;
+    request: RequestFn<Message, Input, Output>;
+    isRequesting(): boolean;
+}
+export default function useXAgent<Message = string, Input = RequestFnInfo<Message>, Output = SSEOutput>(config: MaybeRefOrGetter<XAgentConfig<Message, Input, Output>>): import("vue").ComputedRef<XAgent<Message, Input, Output>>[];
+export {};

package/antx/use-x-chat/index.d.ts

@@ -0,0 +1,4 @@
+import useXChat from './use-x-chat';
+export type { SimpleType, MessageStatus, XChatConfig, MessageInfo, DefaultMessageInfo, RequestResultObject, StandardRequestResult } from './use-x-chat';
+export { useXChat };
+export default useXChat;