@vunk/plus 1.8.0 → 1.8.2

package/components/sender/src/index.vue.d.ts

@@ -0,0 +1,649 @@
+import type { AnyFunc, NormalObject } from '@vunk/shared';
+import type { UploadChangeParam, UploadFile } from 'ant-design-vue';
+import type { AttachmentsRef } from 'ant-design-x-vue/typings/attachments/interface';
+import type { Ref } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    fileList: {
+        type: import("vue").PropType<UploadFile[]>;
+        default: undefined;
+    };
+    action: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    modules: {
+        type: {
+            (arrayLength: number): "Attachments"[];
+            (...items: "Attachments"[]): "Attachments"[];
+            new (arrayLength: number): "Attachments"[];
+            new (...items: "Attachments"[]): "Attachments"[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    sendDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    attachmentsVisible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    createSendButton: {
+        type: import("vue").PropType<AnyFunc>;
+        default: undefined;
+    };
+    createAttachmentsButton: {
+        type: import("vue").PropType<AnyFunc>;
+        default: undefined;
+    };
+    autoSize: {
+        type: import("vue").PropType<{
+            minRows?: number;
+            maxRows?: number;
+        }>;
+        default: undefined;
+    };
+    attachmentsProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, {
+    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        fileList: {
+            type: import("vue").PropType<UploadFile[]>;
+            default: undefined;
+        };
+        action: {
+            type: StringConstructor;
+            default: string;
+        };
+        modelValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        modules: {
+            type: {
+                (arrayLength: number): "Attachments"[];
+                (...items: "Attachments"[]): "Attachments"[];
+                new (arrayLength: number): "Attachments"[];
+                new (...items: "Attachments"[]): "Attachments"[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+            default: () => never[];
+        };
+        sendDisabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        attachmentsVisible: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        createSendButton: {
+            type: import("vue").PropType<AnyFunc>;
+            default: undefined;
+        };
+        createAttachmentsButton: {
+            type: import("vue").PropType<AnyFunc>;
+            default: undefined;
+        };
+        autoSize: {
+            type: import("vue").PropType<{
+                minRows?: number;
+                maxRows?: number;
+            }>;
+            default: undefined;
+        };
+        attachmentsProps: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((_: string) => any) | undefined;
+        onSubmit?: ((_: string) => any) | undefined;
+        "onUpdate:fileList"?: ((_: UploadFile<any>[]) => any) | undefined;
+        "onUpdate:headerVisible"?: ((_: boolean) => any) | undefined;
+        onCancel?: ((...args: any[]) => any) | undefined;
+    }> & {}>;
+    emit: ((event: "update:modelValue", _: string) => void) & ((event: "submit", _: string) => void) & ((event: "update:fileList", _: UploadFile<any>[]) => void) & ((event: "update:headerVisible", _: boolean) => void) & ((event: "cancel", ...args: any[]) => void);
+    slots: Readonly<{
+        [name: string]: import("vue").Slot<any> | undefined;
+    }>;
+    hasAttachments: import("vue").ComputedRef<boolean>;
+    loading: import("vue").WritableComputedRef<boolean, boolean>;
+    headerOpen: import("vue").WritableComputedRef<boolean, boolean>;
+    createSendButtonDefault: (components?: NormalObject) => JSX.Element;
+    createSendButton: (components: any) => any;
+    createAttachmentsButtonDefault: () => JSX.Element;
+    createAttachmentsButton: () => any;
+    actionsRender: AnyFunc;
+    attachmentsPlaceholder: AnyFunc;
+    theFileList: import("vue").WritableComputedRef<UploadFile<any>[], UploadFile<any>[]>;
+    attachmentsRef: Ref<AttachmentsRef, AttachmentsRef>;
+    attachmentWrapDef: {
+        _ref: import("vue").ShallowRef<HTMLDivElement, HTMLDivElement>;
+        readonly value: HTMLDivElement;
+        promise: Promise<HTMLDivElement>;
+        resolve: import("@vunk/core").AnyFunc;
+        reject: (reason?: any) => void;
+    };
+    attachmentWrapResolve: import("@vunk/core").AnyFunc;
+    handlePasteFile: (file: File) => Promise<void>;
+    handleChange: (e: UploadChangeParam<UploadFile>) => void;
+    readonly Attachments: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("ant-design-x-vue").AttachmentsProps> & Readonly<{}>, {
+            nativeElement: HTMLDivElement | null;
+            upload: (file: File | File[] | FileList) => void;
+        }, {}, {}, {}, 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("ant-design-x-vue").AttachmentsProps> & Readonly<{}>, {
+            nativeElement: HTMLDivElement | null;
+            upload: (file: File | File[] | FileList) => void;
+        }, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("ant-design-x-vue").AttachmentsProps> & Readonly<{}>, {
+        nativeElement: HTMLDivElement | null;
+        upload: (file: File | File[] | FileList) => void;
+    }, {}, {}, {}, 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: Readonly<{
+            placeholder?(props?: {
+                type: "inline" | "drop";
+            }): import("vue").VNode | string;
+        }> & {
+            placeholder?(props?: {
+                type: "inline" | "drop";
+            }): import("vue").VNode | string;
+        };
+    }) & {
+        FileCard: import("vue").DefineComponent<import("ant-design-x-vue/typings/attachments/interface").FileListCardProps, {
+            nativeElement: Readonly<import("vue").ShallowRef<HTMLDivElement>>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("ant-design-x-vue/typings/attachments/interface").FileListCardProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+    };
+    readonly Sender: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("ant-design-x-vue").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("ant-design-x-vue").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("ant-design-x-vue").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: Readonly<{
+            header?(): import("vue").VNode;
+            prefix?(): import("vue").VNode;
+            actions?(props: {
+                ori: import("vue").VNode;
+                info: {
+                    components: {
+                        SendButton: typeof import("ant-design-x-vue/typings/sender/components/SendButton.vue").default;
+                        ClearButton: typeof import("ant-design-x-vue/typings/sender/components/ClearButton.vue").default;
+                        LoadingButton: typeof import("ant-design-x-vue/typings/sender/components/LoadingButton.vue").default;
+                        SpeechButton: typeof import("ant-design-x-vue/typings/sender/components/SpeechButton/index.vue").default;
+                    };
+                };
+            }): import("vue").VNode;
+            footer?(props: {
+                info: {
+                    components: {
+                        SendButton: typeof import("ant-design-x-vue/typings/sender/components/SendButton.vue").default;
+                        ClearButton: typeof import("ant-design-x-vue/typings/sender/components/ClearButton.vue").default;
+                        LoadingButton: typeof import("ant-design-x-vue/typings/sender/components/LoadingButton.vue").default;
+                        SpeechButton: typeof import("ant-design-x-vue/typings/sender/components/SpeechButton/index.vue").default;
+                    };
+                };
+            }): import("vue").VNode;
+        }> & {
+            header?(): import("vue").VNode;
+            prefix?(): import("vue").VNode;
+            actions?(props: {
+                ori: import("vue").VNode;
+                info: {
+                    components: {
+                        SendButton: typeof import("ant-design-x-vue/typings/sender/components/SendButton.vue").default;
+                        ClearButton: typeof import("ant-design-x-vue/typings/sender/components/ClearButton.vue").default;
+                        LoadingButton: typeof import("ant-design-x-vue/typings/sender/components/LoadingButton.vue").default;
+                        SpeechButton: typeof import("ant-design-x-vue/typings/sender/components/SpeechButton/index.vue").default;
+                    };
+                };
+            }): import("vue").VNode;
+            footer?(props: {
+                info: {
+                    components: {
+                        SendButton: typeof import("ant-design-x-vue/typings/sender/components/SendButton.vue").default;
+                        ClearButton: typeof import("ant-design-x-vue/typings/sender/components/ClearButton.vue").default;
+                        LoadingButton: typeof import("ant-design-x-vue/typings/sender/components/LoadingButton.vue").default;
+                        SpeechButton: typeof import("ant-design-x-vue/typings/sender/components/SpeechButton/index.vue").default;
+                    };
+                };
+            }): import("vue").VNode;
+        };
+    }) & {
+        Header: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("ant-design-x-vue/typings/sender/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("ant-design-x-vue/typings/sender/interface").SenderHeaderProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("ant-design-x-vue/typings/sender/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: Readonly<{
+                default(props?: any): any;
+            }> & {
+                default(props?: any): any;
+            };
+        });
+    };
+    SenderHeader: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        contentRef: {
+            type: import("vue").PropType<AnyFunc>;
+            default: AnyFunc;
+        };
+    }>, {
+        readonly CloseOutlined: import("@ant-design/icons-vue/lib/icons/CloseOutlined").CloseOutlinedIconType;
+        readonly AntButton: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                type: import("vue").PropType<import("ant-design-vue/es/button").ButtonType>;
+                htmlType: {
+                    type: import("vue").PropType<import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType>;
+                    default: string;
+                };
+                shape: {
+                    type: import("vue").PropType<import("ant-design-vue/es/button").ButtonShape>;
+                };
+                size: {
+                    type: import("vue").PropType<import("ant-design-vue/es/button").ButtonSize>;
+                };
+                loading: {
+                    type: import("vue").PropType<boolean | {
+                        delay?: number;
+                    }>;
+                    default: () => boolean | {
+                        delay?: number;
+                    };
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                ghost: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                block: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                danger: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                icon: import("vue-types").VueTypeValidableDef<any>;
+                href: StringConstructor;
+                target: StringConstructor;
+                title: StringConstructor;
+                onClick: {
+                    type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+                };
+                onMousedown: {
+                    type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+                };
+            }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                block: boolean;
+                disabled: boolean;
+                danger: boolean;
+                ghost: boolean;
+                htmlType: import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType;
+                loading: boolean | {
+                    delay?: number;
+                };
+            }, true, {}, import("ant-design-vue/es/_util/type").CustomSlotsType<{
+                icon: any;
+                default: any;
+            }>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                type: import("vue").PropType<import("ant-design-vue/es/button").ButtonType>;
+                htmlType: {
+                    type: import("vue").PropType<import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType>;
+                    default: string;
+                };
+                shape: {
+                    type: import("vue").PropType<import("ant-design-vue/es/button").ButtonShape>;
+                };
+                size: {
+                    type: import("vue").PropType<import("ant-design-vue/es/button").ButtonSize>;
+                };
+                loading: {
+                    type: import("vue").PropType<boolean | {
+                        delay?: number;
+                    }>;
+                    default: () => boolean | {
+                        delay?: number;
+                    };
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                ghost: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                block: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                danger: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                icon: import("vue-types").VueTypeValidableDef<any>;
+                href: StringConstructor;
+                target: StringConstructor;
+                title: StringConstructor;
+                onClick: {
+                    type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+                };
+                onMousedown: {
+                    type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+                };
+            }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, {
+                block: boolean;
+                disabled: boolean;
+                danger: boolean;
+                ghost: boolean;
+                htmlType: import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType;
+                loading: boolean | {
+                    delay?: number;
+                };
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            prefixCls: StringConstructor;
+            type: import("vue").PropType<import("ant-design-vue/es/button").ButtonType>;
+            htmlType: {
+                type: import("vue").PropType<import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType>;
+                default: string;
+            };
+            shape: {
+                type: import("vue").PropType<import("ant-design-vue/es/button").ButtonShape>;
+            };
+            size: {
+                type: import("vue").PropType<import("ant-design-vue/es/button").ButtonSize>;
+            };
+            loading: {
+                type: import("vue").PropType<boolean | {
+                    delay?: number;
+                }>;
+                default: () => boolean | {
+                    delay?: number;
+                };
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            ghost: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            block: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            danger: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            icon: import("vue-types").VueTypeValidableDef<any>;
+            href: StringConstructor;
+            target: StringConstructor;
+            title: StringConstructor;
+            onClick: {
+                type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+            };
+            onMousedown: {
+                type: import("vue").PropType<import("ant-design-vue/es/_util/EventInterface").MouseEventHandler | import("ant-design-vue/es/_util/EventInterface").MouseEventHandler[]>;
+            };
+        }>> & Readonly<{}>, () => import("ant-design-vue/es/_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            block: boolean;
+            disabled: boolean;
+            danger: boolean;
+            ghost: boolean;
+            htmlType: import("ant-design-vue/es/button/buttonTypes").ButtonHTMLType;
+            loading: boolean | {
+                delay?: number;
+            };
+        }, {}, string, import("ant-design-vue/es/_util/type").CustomSlotsType<{
+            icon: any;
+            default: any;
+        }>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (import("vue").Plugin<any[]> & {
+            readonly Group: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                size: {
+                    type: import("vue").PropType<import("ant-design-vue/es/button").ButtonSize>;
+                };
+            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                prefixCls: StringConstructor;
+                size: {
+                    type: import("vue").PropType<import("ant-design-vue/es/button").ButtonSize>;
+                };
+            }>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }));
+        readonly ElCollapseTransition: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) & import("vue").Plugin;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:modelValue': null;
+    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        title: {
+            type: StringConstructor;
+            default: string;
+        };
+        contentRef: {
+            type: import("vue").PropType<AnyFunc>;
+            default: AnyFunc;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        modelValue: boolean;
+        title: string;
+        contentRef: AnyFunc;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:fileList': (_: UploadFile[]) => boolean;
+    'update:modelValue': (_: string) => boolean;
+    'update:headerVisible': (_: boolean) => boolean;
+    submit: (_: string) => boolean;
+    cancel: null;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    fileList: {
+        type: import("vue").PropType<UploadFile[]>;
+        default: undefined;
+    };
+    action: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    modules: {
+        type: {
+            (arrayLength: number): "Attachments"[];
+            (...items: "Attachments"[]): "Attachments"[];
+            new (arrayLength: number): "Attachments"[];
+            new (...items: "Attachments"[]): "Attachments"[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    sendDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    attachmentsVisible: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    createSendButton: {
+        type: import("vue").PropType<AnyFunc>;
+        default: undefined;
+    };
+    createAttachmentsButton: {
+        type: import("vue").PropType<AnyFunc>;
+        default: undefined;
+    };
+    autoSize: {
+        type: import("vue").PropType<{
+            minRows?: number;
+            maxRows?: number;
+        }>;
+        default: undefined;
+    };
+    attachmentsProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_: string) => any) | undefined;
+    onSubmit?: ((_: string) => any) | undefined;
+    "onUpdate:fileList"?: ((_: UploadFile<any>[]) => any) | undefined;
+    "onUpdate:headerVisible"?: ((_: boolean) => any) | undefined;
+    onCancel?: ((...args: any[]) => any) | undefined;
+}>, {
+    loading: boolean;
+    modules: "Attachments"[];
+    modelValue: string;
+    fileList: UploadFile<any>[];
+    action: string;
+    sendDisabled: boolean;
+    attachmentsVisible: boolean;
+    createSendButton: AnyFunc;
+    createAttachmentsButton: AnyFunc;
+    autoSize: {
+        minRows?: number;
+        maxRows?: number;
+    };
+    attachmentsProps: Record<string, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/sender/src/types.d.ts

@@ -0,0 +1 @@
+export type Module = 'Attachments';

package/components/speech-button/index.d.ts

@@ -0,0 +1,4 @@
+import VkSpeechButton from './src/index.vue';
+export * as __VkSpeechButton from './src/types';
+export { VkSpeechButton, };
+export default VkSpeechButton;

package/components/speech-button/index.mjs

@@ -2,7 +2,7 @@ import { defineComponent, createVNode, createTextVNode } from 'vue';
 import { useRecorder } from '@vunk/plus/composables/recorder';
 import { Button } from 'ant-design-vue';
 import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
-import { A as AudioMutedOutlined, b as AudioOutlined } from '../SendOutlined.mjs';
+import { A as AudioMutedOutlined, b as AudioOutlined } from '../LinkOutlined.mjs';
 
 const props = {
   disabled: {

package/components/speech-button/src/LoadingIcon.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;