@vunk/plus 1.3.9 → 1.3.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (24) hide show
  1. package/components/agent-chat-provider/src/index.vue.d.ts +3 -3
  2. package/components/agent-chat-provider/src/types.d.ts +5 -0
  3. package/components/broadcasting-markdown/index.mjs +18 -6
  4. package/components/broadcasting-markdown/src/ctx.d.ts +1 -0
  5. package/components/broadcasting-markdown/src/index.vue.d.ts +3 -0
  6. package/components/bubble-list/src/index.vue.d.ts +5 -2
  7. package/components/bubble-templates/index.mjs +21 -5
  8. package/components/bubble-templates/src/index.vue.d.ts +9 -6
  9. package/components/bubble-templates/src/types.d.ts +4 -0
  10. package/components/chat-independent/index.mjs +41 -15
  11. package/components/chat-independent/src/index.vue.d.ts +654 -637
  12. package/components/recorder-button/index.mjs +4 -7
  13. package/components/recorder-button/src/ctx.d.ts +1 -0
  14. package/components/recorder-button/src/index.vue.d.ts +23 -26
  15. package/components/sender/index.mjs +11 -8
  16. package/components/sender/src/ctx.d.ts +4 -0
  17. package/components/sender/src/index.vue.d.ts +12 -3
  18. package/components/table-columns/src/el-ctx.d.ts +1 -1
  19. package/components/tables-v1/src/ctx.d.ts +1 -1
  20. package/components/tables-v1/src/index.vue.d.ts +1 -1
  21. package/components/tables-v1-checkbox/src/ctx.d.ts +2 -2
  22. package/components/tables-v1-checkbox/src/index.vue.d.ts +5 -5
  23. package/composables/recorder/index.mjs +8 -5
  24. package/package.json +1 -1
package/components/chat-independent/src/index.vue.d.ts CHANGED
@@ -25,152 +25,378 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
25
25
  onSetData?: ((e: import("@vunk/core").SetDataEvent) => any) | undefined;
26
26
  }> & {}>;
27
27
  emit: (event: "setData", e: import("@vunk/core").SetDataEvent) => void;
28
- bubbleData: import("vue").ComputedRef<import("../../bubble-templates/src/types").RenderData>;
29
- setBubbleData: (e: import("@vunk/core").SetDataEvent) => void;
30
- mainRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
31
- inputType: import("vue").Ref<InputType, InputType>;
32
- content: import("vue").Ref<string, string>;
33
- bubbleListDef: {
34
- _ref: import("vue").ShallowRef<{
35
- scrollToBottom: () => void;
36
- }, {
37
- scrollToBottom: () => void;
38
- }>;
39
- readonly value: {
40
- scrollToBottom: () => void;
28
+ VkRecorderButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
29
+ onTextZone: {
30
+ type: import("vue").PropType<import("../../recorder-button/src/types").OnTextZone>;
31
+ default: undefined;
41
32
  };
42
- promise: Promise<{
43
- scrollToBottom: () => void;
44
- }>;
45
- resolve: import("@vunk/core").AnyFunc;
46
- reject: (reason?: any) => void;
47
- };
48
- bubbleListReslove: import("@vunk/core").AnyFunc;
49
- simplicity: {
50
- onRequest: (message: string) => void;
51
- items: import("vue").ComputedRef<import("../../agent-chat-provider/src/types").BubbleItem[]>;
52
- };
53
- bubbleItems: import("vue").ComputedRef<import("../../agent-chat-provider/src/types").BubbleItem[]>;
54
- onRequest: (message: string) => void;
55
- lastBubbleData: import("vue").ComputedRef<import("../../bubble-templates/src/types").RenderDataRecord>;
56
- senderDisabled: import("vue").ComputedRef<boolean>;
57
- onSubmit: (nextContent: string) => void;
58
- readonly VkBubbleList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
59
- items: {
60
- type: {
61
- (arrayLength: number): import("../../agent-chat-provider/src/types").BubbleItem[];
62
- (...items: import("../../agent-chat-provider/src/types").BubbleItem[]): import("../../agent-chat-provider/src/types").BubbleItem[];
63
- new (arrayLength: number): import("../../agent-chat-provider/src/types").BubbleItem[];
64
- new (...items: import("../../agent-chat-provider/src/types").BubbleItem[]): import("../../agent-chat-provider/src/types").BubbleItem[];
65
- isArray(arg: any): arg is any[];
66
- readonly prototype: any[];
67
- from<T>(arrayLike: ArrayLike<T>): T[];
68
- from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
69
- from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
70
- from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
71
- of<T_4>(...items: T_4[]): T_4[];
72
- readonly [Symbol.species]: ArrayConstructor;
73
- };
74
- default: () => never[];
33
+ appendTo: {
34
+ type: null;
35
+ default: string;
75
36
  };
76
- elRef: {
77
- type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
78
- default: import("@vunk/shared").AnyFunc;
37
+ disabled: {
38
+ type: BooleanConstructor;
39
+ default: boolean;
79
40
  };
80
- textToSpeech: {
81
- type: import("vue").PropType<import("./types").TextToSpeech>;
41
+ speechToText: {
42
+ type: import("vue").PropType<import("./types").SpeechToText>;
43
+ default: undefined;
44
+ };
45
+ submitToText: {
46
+ type: BooleanConstructor;
47
+ default: boolean;
82
48
  };
83
49
  }>, {
84
- getContentWraper: (e: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
85
- [key: string]: any;
86
- }>) => import("vue").RendererNode | null;
87
- readonly VkBubbleTemplates: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
88
- textToSpeech: {
89
- type: import("vue").PropType<import("./types").TextToSpeech>;
90
- };
91
- modules: {
92
- type: import("vue").PropType<"Thinking"[]>;
93
- default: () => string[];
94
- };
95
- }>, {
96
- initRenderData: (emitSetData: any, props: any) => void;
97
- typed: (e: import("../../agent-chat-provider/src/types").BubbleItem) => import("../../agent-chat-provider/src/types").BubbleItem;
98
- readonly VkBroadcastingMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
99
- render: {
100
- type: import("vue").PropType<(text: string) => string>;
101
- default: typeof import("../../broadcasting-markdown").defaultRender;
102
- };
103
- data: {
104
- type: {
105
- (arrayLength: number): import("../../broadcasting-markdown/src/types").Paragraph[];
106
- (...items: import("../../broadcasting-markdown/src/types").Paragraph[]): import("../../broadcasting-markdown/src/types").Paragraph[];
107
- new (arrayLength: number): import("../../broadcasting-markdown/src/types").Paragraph[];
108
- new (...items: import("../../broadcasting-markdown/src/types").Paragraph[]): import("../../broadcasting-markdown/src/types").Paragraph[];
109
- isArray(arg: any): arg is any[];
110
- readonly prototype: any[];
111
- from<T>(arrayLike: ArrayLike<T>): T[];
112
- from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
113
- from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
114
- from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
115
- of<T_4>(...items: T_4[]): T_4[];
116
- readonly [Symbol.species]: ArrayConstructor;
117
- };
118
- default: undefined;
119
- };
120
- source: {
121
- type: StringConstructor;
122
- default: string;
123
- };
124
- delay: {
125
- type: NumberConstructor;
126
- default: number;
127
- };
128
- separators: {
129
- type: {
130
- (arrayLength: number): string[];
131
- (...items: string[]): string[];
132
- new (arrayLength: number): string[];
133
- new (...items: string[]): string[];
134
- isArray(arg: any): arg is any[];
135
- readonly prototype: any[];
136
- from<T>(arrayLike: ArrayLike<T>): T[];
137
- from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
138
- from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
139
- from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
140
- of<T_4>(...items: T_4[]): T_4[];
141
- readonly [Symbol.species]: ArrayConstructor;
142
- };
143
- default: () => string[];
144
- };
145
- pause: {
146
- type: BooleanConstructor;
147
- default: boolean;
50
+ onmousedown: (e: MouseEvent | TouchEvent) => void;
51
+ onmousemove: (e: MouseEvent | TouchEvent) => void;
52
+ onmouseup: (e: MouseEvent | TouchEvent) => void;
53
+ recording: import("vue").Ref<boolean, boolean>;
54
+ recordingNode: import("vue").Ref<HTMLSpanElement, HTMLSpanElement>;
55
+ blobUrl: import("vue").Ref<string, string>;
56
+ isDragging: import("vue").Ref<boolean, boolean>;
57
+ cancelZone: import("vue").Ref<boolean, boolean>;
58
+ isTextZone: import("vue").Ref<boolean, boolean>;
59
+ }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
60
+ submitText: (text: string) => boolean;
61
+ submit: (_: import("../../recorder-button/src/types").SubmitRawEvent) => boolean;
62
+ error: (_: Error) => boolean;
63
+ }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
64
+ onTextZone: {
65
+ type: import("vue").PropType<import("../../recorder-button/src/types").OnTextZone>;
66
+ default: undefined;
67
+ };
68
+ appendTo: {
69
+ type: null;
70
+ default: string;
71
+ };
72
+ disabled: {
73
+ type: BooleanConstructor;
74
+ default: boolean;
75
+ };
76
+ speechToText: {
77
+ type: import("vue").PropType<import("./types").SpeechToText>;
78
+ default: undefined;
79
+ };
80
+ submitToText: {
81
+ type: BooleanConstructor;
82
+ default: boolean;
83
+ };
84
+ }>> & Readonly<{
85
+ onError?: ((_: Error) => any) | undefined;
86
+ onSubmit?: ((_: import("../../recorder-button/src/types").SubmitRawEvent) => any) | undefined;
87
+ onSubmitText?: ((text: string) => any) | undefined;
88
+ }>, {
89
+ disabled: boolean;
90
+ onTextZone: import("../../recorder-button/src/types").OnTextZone;
91
+ appendTo: any;
92
+ speechToText: import("./types").SpeechToText;
93
+ submitToText: boolean;
94
+ }, {}, {
95
+ ElButton: import("element-plus/es/utils").SFCWithInstall<{
96
+ new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
97
+ readonly size: {
98
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
99
+ readonly required: false;
100
+ readonly validator: ((val: unknown) => boolean) | undefined;
101
+ __epPropKey: true;
148
102
  };
149
- keepRead: {
150
- type: BooleanConstructor;
151
- default: boolean;
103
+ readonly disabled: BooleanConstructor;
104
+ readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown, "", boolean>;
105
+ readonly icon: {
106
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
107
+ readonly required: false;
108
+ readonly validator: ((val: unknown) => boolean) | undefined;
109
+ __epPropKey: true;
152
110
  };
153
- webSpeech: {
154
- type: BooleanConstructor;
155
- default: boolean;
111
+ readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "submit" | "button" | "reset", unknown, "button", boolean>;
112
+ readonly loading: BooleanConstructor;
113
+ readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
114
+ readonly plain: BooleanConstructor;
115
+ readonly text: BooleanConstructor;
116
+ readonly link: BooleanConstructor;
117
+ readonly bg: BooleanConstructor;
118
+ readonly autofocus: BooleanConstructor;
119
+ readonly round: BooleanConstructor;
120
+ readonly circle: BooleanConstructor;
121
+ readonly color: StringConstructor;
122
+ readonly dark: BooleanConstructor;
123
+ readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
124
+ readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
125
+ }>> & {
126
+ onClick?: ((evt: MouseEvent) => any) | undefined;
127
+ }, {
128
+ ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
129
+ size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
130
+ type: import("vue").ComputedRef<"" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning">;
131
+ disabled: import("vue").ComputedRef<boolean>;
132
+ shouldAddSpace: import("vue").ComputedRef<boolean>;
133
+ }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
134
+ click: (evt: MouseEvent) => void;
135
+ }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
136
+ readonly link: boolean;
137
+ readonly circle: boolean;
138
+ readonly text: boolean;
139
+ readonly disabled: boolean;
140
+ readonly round: boolean;
141
+ readonly dark: boolean;
142
+ readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown>;
143
+ readonly bg: boolean;
144
+ readonly loading: boolean;
145
+ readonly autofocus: boolean;
146
+ readonly tag: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
147
+ readonly nativeType: import("element-plus").ButtonType<StringConstructor, "submit" | "button" | "reset", unknown>;
148
+ readonly loadingIcon: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
149
+ readonly autoInsertSpace: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
150
+ readonly plain: boolean;
151
+ }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
152
+ P: {};
153
+ B: {};
154
+ D: {};
155
+ C: {};
156
+ M: {};
157
+ Defaults: {};
158
+ }, Readonly<import("vue").ExtractPropTypes<{
159
+ readonly size: {
160
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
161
+ readonly required: false;
162
+ readonly validator: ((val: unknown) => boolean) | undefined;
163
+ __epPropKey: true;
156
164
  };
157
- textToSpeech: {
158
- type: import("vue").PropType<import("./types").TextToSpeech>;
159
- default: undefined;
165
+ readonly disabled: BooleanConstructor;
166
+ readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown, "", boolean>;
167
+ readonly icon: {
168
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
169
+ readonly required: false;
170
+ readonly validator: ((val: unknown) => boolean) | undefined;
171
+ __epPropKey: true;
160
172
  };
161
- }>, {
162
- theData: import("vue").ComputedRef<import("../../broadcasting-markdown/src/types").Paragraph[]>;
163
- ParagraphStatus: typeof import("../../broadcasting-markdown").ParagraphStatus;
164
- fulfilledTextValue: import("vue").ComputedRef<string>;
165
- isPrevParagraphFulfilled: (currentIndex: number) => boolean;
166
- isParagraphEnabled: (currentIndex: number) => boolean;
167
- processingParagraph: (paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => Promise<void> | undefined;
168
- }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
169
- setData: (e: import("@vunk/core").SetDataEvent) => import("@vunk/core").SetDataEvent;
170
- 'update:broadcasting': (_: boolean) => boolean;
171
- 'update:completed': (_: boolean) => boolean;
172
- 'update:error': (_: boolean) => boolean;
173
- }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
173
+ readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "submit" | "button" | "reset", unknown, "button", boolean>;
174
+ readonly loading: BooleanConstructor;
175
+ readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
176
+ readonly plain: BooleanConstructor;
177
+ readonly text: BooleanConstructor;
178
+ readonly link: BooleanConstructor;
179
+ readonly bg: BooleanConstructor;
180
+ readonly autofocus: BooleanConstructor;
181
+ readonly round: BooleanConstructor;
182
+ readonly circle: BooleanConstructor;
183
+ readonly color: StringConstructor;
184
+ readonly dark: BooleanConstructor;
185
+ readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
186
+ readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
187
+ }>> & {
188
+ onClick?: ((evt: MouseEvent) => any) | undefined;
189
+ }, {
190
+ ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
191
+ size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
192
+ type: import("vue").ComputedRef<"" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning">;
193
+ disabled: import("vue").ComputedRef<boolean>;
194
+ shouldAddSpace: import("vue").ComputedRef<boolean>;
195
+ }, {}, {}, {}, {
196
+ readonly link: boolean;
197
+ readonly circle: boolean;
198
+ readonly text: boolean;
199
+ readonly disabled: boolean;
200
+ readonly round: boolean;
201
+ readonly dark: boolean;
202
+ readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown>;
203
+ readonly bg: boolean;
204
+ readonly loading: boolean;
205
+ readonly autofocus: boolean;
206
+ readonly tag: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
207
+ readonly nativeType: import("element-plus").ButtonType<StringConstructor, "submit" | "button" | "reset", unknown>;
208
+ readonly loadingIcon: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
209
+ readonly autoInsertSpace: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
210
+ readonly plain: boolean;
211
+ }>;
212
+ __isFragment?: undefined;
213
+ __isTeleport?: undefined;
214
+ __isSuspense?: undefined;
215
+ } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
216
+ readonly size: {
217
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
218
+ readonly required: false;
219
+ readonly validator: ((val: unknown) => boolean) | undefined;
220
+ __epPropKey: true;
221
+ };
222
+ readonly disabled: BooleanConstructor;
223
+ readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown, "", boolean>;
224
+ readonly icon: {
225
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
226
+ readonly required: false;
227
+ readonly validator: ((val: unknown) => boolean) | undefined;
228
+ __epPropKey: true;
229
+ };
230
+ readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "submit" | "button" | "reset", unknown, "button", boolean>;
231
+ readonly loading: BooleanConstructor;
232
+ readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
233
+ readonly plain: BooleanConstructor;
234
+ readonly text: BooleanConstructor;
235
+ readonly link: BooleanConstructor;
236
+ readonly bg: BooleanConstructor;
237
+ readonly autofocus: BooleanConstructor;
238
+ readonly round: BooleanConstructor;
239
+ readonly circle: BooleanConstructor;
240
+ readonly color: StringConstructor;
241
+ readonly dark: BooleanConstructor;
242
+ readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
243
+ readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
244
+ }>> & {
245
+ onClick?: ((evt: MouseEvent) => any) | undefined;
246
+ }, {
247
+ ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
248
+ size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
249
+ type: import("vue").ComputedRef<"" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning">;
250
+ disabled: import("vue").ComputedRef<boolean>;
251
+ shouldAddSpace: import("vue").ComputedRef<boolean>;
252
+ }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
253
+ click: (evt: MouseEvent) => void;
254
+ }, string, {
255
+ readonly link: boolean;
256
+ readonly circle: boolean;
257
+ readonly text: boolean;
258
+ readonly disabled: boolean;
259
+ readonly round: boolean;
260
+ readonly dark: boolean;
261
+ readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown>;
262
+ readonly bg: boolean;
263
+ readonly loading: boolean;
264
+ readonly autofocus: boolean;
265
+ readonly tag: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
266
+ readonly nativeType: import("element-plus").ButtonType<StringConstructor, "submit" | "button" | "reset", unknown>;
267
+ readonly loadingIcon: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
268
+ readonly autoInsertSpace: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
269
+ readonly plain: boolean;
270
+ }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
271
+ $slots: {
272
+ loading?(_: {}): any;
273
+ icon?(_: {}): any;
274
+ default?(_: {}): any;
275
+ };
276
+ })> & {
277
+ ButtonGroup: {
278
+ new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
279
+ readonly size: {
280
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
281
+ readonly required: false;
282
+ readonly validator: ((val: unknown) => boolean) | undefined;
283
+ __epPropKey: true;
284
+ };
285
+ readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown, "", boolean>;
286
+ }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
287
+ readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown>;
288
+ }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
289
+ P: {};
290
+ B: {};
291
+ D: {};
292
+ C: {};
293
+ M: {};
294
+ Defaults: {};
295
+ }, Readonly<import("vue").ExtractPropTypes<{
296
+ readonly size: {
297
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
298
+ readonly required: false;
299
+ readonly validator: ((val: unknown) => boolean) | undefined;
300
+ __epPropKey: true;
301
+ };
302
+ readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown, "", boolean>;
303
+ }>>, {}, {}, {}, {}, {
304
+ readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown>;
305
+ }>;
306
+ __isFragment?: undefined;
307
+ __isTeleport?: undefined;
308
+ __isSuspense?: undefined;
309
+ } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
310
+ readonly size: {
311
+ readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
312
+ readonly required: false;
313
+ readonly validator: ((val: unknown) => boolean) | undefined;
314
+ __epPropKey: true;
315
+ };
316
+ readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown, "", boolean>;
317
+ }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
318
+ readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "danger" | "primary" | "text" | "warning", unknown>;
319
+ }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
320
+ $slots: {
321
+ default?(_: {}): any;
322
+ };
323
+ });
324
+ };
325
+ }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
326
+ bubbleData: import("vue").ComputedRef<import("../../bubble-templates/src/types").RenderData>;
327
+ setBubbleData: (e: import("@vunk/core").SetDataEvent) => void;
328
+ mainRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
329
+ inputType: import("vue").Ref<InputType, InputType>;
330
+ content: import("vue").Ref<string, string>;
331
+ bubbleListDef: {
332
+ _ref: import("vue").ShallowRef<{
333
+ scrollToBottom: () => void;
334
+ }, {
335
+ scrollToBottom: () => void;
336
+ }>;
337
+ readonly value: {
338
+ scrollToBottom: () => void;
339
+ };
340
+ promise: Promise<{
341
+ scrollToBottom: () => void;
342
+ }>;
343
+ resolve: import("@vunk/core").AnyFunc;
344
+ reject: (reason?: any) => void;
345
+ };
346
+ bubbleListReslove: import("@vunk/core").AnyFunc;
347
+ simplicity: {
348
+ onRequest: (message: string) => void;
349
+ items: import("vue").ComputedRef<import("../../agent-chat-provider/src/types").BubbleItem[]>;
350
+ };
351
+ bubbleItems: import("vue").ComputedRef<import("../../agent-chat-provider/src/types").BubbleItem[]>;
352
+ onRequest: (message: string) => void;
353
+ lastBubbleData: import("vue").ComputedRef<import("../../bubble-templates/src/types").RenderDataRecord>;
354
+ clientLoading: import("vue").ComputedRef<boolean>;
355
+ senderDisabled: import("vue").ComputedRef<boolean>;
356
+ onSubmit: (nextContent: string) => void;
357
+ onCancel: () => void;
358
+ getBubbleDataAt: (index: number) => import("../../bubble-templates/src/types").RenderDataRecord;
359
+ readonly VkBubbleList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
360
+ items: {
361
+ type: {
362
+ (arrayLength: number): import("../../agent-chat-provider/src/types").BubbleItem[];
363
+ (...items: import("../../agent-chat-provider/src/types").BubbleItem[]): import("../../agent-chat-provider/src/types").BubbleItem[];
364
+ new (arrayLength: number): import("../../agent-chat-provider/src/types").BubbleItem[];
365
+ new (...items: import("../../agent-chat-provider/src/types").BubbleItem[]): import("../../agent-chat-provider/src/types").BubbleItem[];
366
+ isArray(arg: any): arg is any[];
367
+ readonly prototype: any[];
368
+ from<T>(arrayLike: ArrayLike<T>): T[];
369
+ from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
370
+ from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
371
+ from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
372
+ of<T_4>(...items: T_4[]): T_4[];
373
+ readonly [Symbol.species]: ArrayConstructor;
374
+ };
375
+ default: () => never[];
376
+ };
377
+ elRef: {
378
+ type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
379
+ default: import("@vunk/shared").AnyFunc;
380
+ };
381
+ textToSpeech: {
382
+ type: import("vue").PropType<import("./types").TextToSpeech>;
383
+ };
384
+ }>, {
385
+ getContentWraper: (e: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
386
+ [key: string]: any;
387
+ }>) => import("vue").RendererNode | null;
388
+ readonly VkBubbleTemplates: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
389
+ textToSpeech: {
390
+ type: import("vue").PropType<import("./types").TextToSpeech>;
391
+ };
392
+ modules: {
393
+ type: import("vue").PropType<"Thinking"[]>;
394
+ default: () => string[];
395
+ };
396
+ }>, {
397
+ setRef: (emitSetData: (e: import("@vunk/core").SetDataEvent) => void, props: import("../../agent-chat-provider/src/types").BubbleItem, el: any) => void;
398
+ initRenderData: (emitSetData: (e: import("@vunk/core").SetDataEvent) => void, props: import("../../agent-chat-provider/src/types").BubbleItem) => void;
399
+ readonly VkBroadcastingMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
174
400
  render: {
175
401
  type: import("vue").PropType<(text: string) => string>;
176
402
  default: typeof import("../../broadcasting-markdown").defaultRender;
@@ -233,50 +459,128 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
233
459
  type: import("vue").PropType<import("./types").TextToSpeech>;
234
460
  default: undefined;
235
461
  };
236
- }>> & Readonly<{
237
- onSetData?: ((e: import("@vunk/core").SetDataEvent) => any) | undefined;
238
- "onUpdate:broadcasting"?: ((_: boolean) => any) | undefined;
239
- "onUpdate:completed"?: ((_: boolean) => any) | undefined;
240
- "onUpdate:error"?: ((_: boolean) => any) | undefined;
241
462
  }>, {
242
- source: string;
243
- delay: number;
244
- pause: boolean;
245
- render: (text: string) => string;
246
- data: import("../../broadcasting-markdown/src/types").Paragraph[];
247
- separators: string[];
248
- keepRead: boolean;
249
- webSpeech: boolean;
250
- textToSpeech: import("./types").TextToSpeech;
251
- }, {}, {
252
- ParagraphView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
253
- enable: {
254
- type: BooleanConstructor;
255
- default: boolean;
256
- };
257
- status: {
258
- type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
259
- default: import("../../broadcasting-markdown").ParagraphStatus;
260
- };
261
- pause: {
262
- type: BooleanConstructor;
263
- default: boolean;
264
- };
265
- processing: {
266
- type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
267
- default: import("@vunk/shared").AnyFunc;
268
- };
269
- retryTimes: {
270
- type: NumberConstructor;
271
- default: number;
272
- };
273
- }>, {
274
- props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
275
- enable: {
276
- type: BooleanConstructor;
277
- default: boolean;
278
- };
279
- status: {
463
+ theData: import("vue").ComputedRef<import("../../broadcasting-markdown/src/types").Paragraph[]>;
464
+ ParagraphStatus: typeof import("../../broadcasting-markdown").ParagraphStatus;
465
+ fulfilledTextValue: import("vue").ComputedRef<string>;
466
+ isPrevParagraphFulfilled: (currentIndex: number) => boolean;
467
+ isParagraphEnabled: (currentIndex: number) => boolean;
468
+ processingParagraph: (paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => Promise<void> | undefined;
469
+ thePause: import("vue").ComputedRef<boolean>;
470
+ }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
471
+ setData: (e: import("@vunk/core").SetDataEvent) => import("@vunk/core").SetDataEvent;
472
+ interrupt: null;
473
+ 'update:broadcasting': (_: boolean) => boolean;
474
+ 'update:completed': (_: boolean) => boolean;
475
+ 'update:error': (_: boolean) => boolean;
476
+ }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
477
+ render: {
478
+ type: import("vue").PropType<(text: string) => string>;
479
+ default: typeof import("../../broadcasting-markdown").defaultRender;
480
+ };
481
+ data: {
482
+ type: {
483
+ (arrayLength: number): import("../../broadcasting-markdown/src/types").Paragraph[];
484
+ (...items: import("../../broadcasting-markdown/src/types").Paragraph[]): import("../../broadcasting-markdown/src/types").Paragraph[];
485
+ new (arrayLength: number): import("../../broadcasting-markdown/src/types").Paragraph[];
486
+ new (...items: import("../../broadcasting-markdown/src/types").Paragraph[]): import("../../broadcasting-markdown/src/types").Paragraph[];
487
+ isArray(arg: any): arg is any[];
488
+ readonly prototype: any[];
489
+ from<T>(arrayLike: ArrayLike<T>): T[];
490
+ from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
491
+ from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
492
+ from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
493
+ of<T_4>(...items: T_4[]): T_4[];
494
+ readonly [Symbol.species]: ArrayConstructor;
495
+ };
496
+ default: undefined;
497
+ };
498
+ source: {
499
+ type: StringConstructor;
500
+ default: string;
501
+ };
502
+ delay: {
503
+ type: NumberConstructor;
504
+ default: number;
505
+ };
506
+ separators: {
507
+ type: {
508
+ (arrayLength: number): string[];
509
+ (...items: string[]): string[];
510
+ new (arrayLength: number): string[];
511
+ new (...items: string[]): string[];
512
+ isArray(arg: any): arg is any[];
513
+ readonly prototype: any[];
514
+ from<T>(arrayLike: ArrayLike<T>): T[];
515
+ from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
516
+ from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
517
+ from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
518
+ of<T_4>(...items: T_4[]): T_4[];
519
+ readonly [Symbol.species]: ArrayConstructor;
520
+ };
521
+ default: () => string[];
522
+ };
523
+ pause: {
524
+ type: BooleanConstructor;
525
+ default: boolean;
526
+ };
527
+ keepRead: {
528
+ type: BooleanConstructor;
529
+ default: boolean;
530
+ };
531
+ webSpeech: {
532
+ type: BooleanConstructor;
533
+ default: boolean;
534
+ };
535
+ textToSpeech: {
536
+ type: import("vue").PropType<import("./types").TextToSpeech>;
537
+ default: undefined;
538
+ };
539
+ }>> & Readonly<{
540
+ onSetData?: ((e: import("@vunk/core").SetDataEvent) => any) | undefined;
541
+ onInterrupt?: ((...args: any[]) => any) | undefined;
542
+ "onUpdate:broadcasting"?: ((_: boolean) => any) | undefined;
543
+ "onUpdate:completed"?: ((_: boolean) => any) | undefined;
544
+ "onUpdate:error"?: ((_: boolean) => any) | undefined;
545
+ }>, {
546
+ source: string;
547
+ delay: number;
548
+ pause: boolean;
549
+ render: (text: string) => string;
550
+ data: import("../../broadcasting-markdown/src/types").Paragraph[];
551
+ separators: string[];
552
+ keepRead: boolean;
553
+ webSpeech: boolean;
554
+ textToSpeech: import("./types").TextToSpeech;
555
+ }, {}, {
556
+ ParagraphView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
557
+ enable: {
558
+ type: BooleanConstructor;
559
+ default: boolean;
560
+ };
561
+ status: {
562
+ type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
563
+ default: import("../../broadcasting-markdown").ParagraphStatus;
564
+ };
565
+ pause: {
566
+ type: BooleanConstructor;
567
+ default: boolean;
568
+ };
569
+ processing: {
570
+ type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
571
+ default: import("@vunk/shared").AnyFunc;
572
+ };
573
+ retryTimes: {
574
+ type: NumberConstructor;
575
+ default: number;
576
+ };
577
+ }>, {
578
+ props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
579
+ enable: {
580
+ type: BooleanConstructor;
581
+ default: boolean;
582
+ };
583
+ status: {
280
584
  type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
281
585
  default: import("../../broadcasting-markdown").ParagraphStatus;
282
586
  };
@@ -888,467 +1192,171 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
888
1192
  readonly validator: ((val: unknown) => boolean) | undefined;
889
1193
  __epPropKey: true;
890
1194
  };
891
- }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
892
- readonly disableWidth: BooleanConstructor;
893
- readonly disableHeight: BooleanConstructor;
894
- readonly onResize: {
895
- readonly type: import("vue").PropType<(event: {
896
- height: number;
897
- width: number;
898
- }) => void>;
899
- readonly required: false;
900
- readonly validator: ((val: unknown) => boolean) | undefined;
901
- __epPropKey: true;
902
- };
903
- }>>, {
904
- readonly disableWidth: boolean;
905
- readonly disableHeight: boolean;
906
- }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
907
- readonly BubbleList: <T_5 extends import("vue-element-plus-x/types/components/Bubble/types").BubbleProps>(__VLS_props: {
908
- readonly onComplete?: ((...args: any[]) => any) | undefined;
909
- list: T_5[];
910
- maxHeight?: string | undefined;
911
- triggerIndices?: number[] | "all" | "only-last" | undefined;
912
- alwaysShowScrollbar?: boolean | undefined;
913
- backButtonThreshold?: number | undefined;
914
- showBackButton?: boolean | undefined;
915
- backButtonPosition?: import("vue-element-plus-x/types/components/BubbleList/types").BackButtonPosition | undefined;
916
- btnLoading?: boolean | undefined;
917
- btnColor?: string | undefined;
918
- btnIconSize?: number | undefined;
919
- } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: {
920
- slots: {
921
- avatar?(_: {
922
- item: T_5;
923
- }): any;
924
- header?(_: {
925
- item: T_5;
926
- }): any;
927
- content?(_: {
928
- item: T_5;
929
- }): any;
930
- footer?(_: {
931
- item: T_5;
932
- }): any;
933
- loading?(_: {
934
- item: T_5;
935
- }): any;
936
- backToBottom?(_: {}): any;
937
- };
938
- emit: (event: "complete", ...args: any[]) => void;
939
- attrs: any;
940
- } | undefined, __VLS_expose?: ((exposed: import("vue").ShallowUnwrapRef<{
941
- scrollToTop: () => void;
942
- scrollToBottom: () => void;
943
- scrollToBubble: (index: number) => void;
944
- }>) => void) | undefined, __VLS_setup?: Promise<{
945
- props: {
946
- readonly onComplete?: ((...args: any[]) => any) | undefined;
947
- list: T_5[];
948
- maxHeight?: string | undefined;
949
- triggerIndices?: number[] | "all" | "only-last" | undefined;
950
- alwaysShowScrollbar?: boolean | undefined;
951
- backButtonThreshold?: number | undefined;
952
- showBackButton?: boolean | undefined;
953
- backButtonPosition?: import("vue-element-plus-x/types/components/BubbleList/types").BackButtonPosition | undefined;
954
- btnLoading?: boolean | undefined;
955
- btnColor?: string | undefined;
956
- btnIconSize?: number | undefined;
957
- } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
958
- expose(exposed: import("vue").ShallowUnwrapRef<{
959
- scrollToTop: () => void;
960
- scrollToBottom: () => void;
961
- scrollToBubble: (index: number) => void;
962
- }>): void;
963
- attrs: any;
964
- slots: {
965
- avatar?(_: {
966
- item: T_5;
967
- }): any;
968
- header?(_: {
969
- item: T_5;
970
- }): any;
971
- content?(_: {
972
- item: T_5;
973
- }): any;
974
- footer?(_: {
975
- item: T_5;
976
- }): any;
977
- loading?(_: {
978
- item: T_5;
979
- }): any;
980
- backToBottom?(_: {}): any;
981
- };
982
- emit: (event: "complete", ...args: any[]) => void;
983
- }> | undefined) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
984
- [key: string]: any;
985
- }> & {
986
- __ctx?: {
987
- props: {
988
- readonly onComplete?: ((...args: any[]) => any) | undefined;
989
- list: T_5[];
990
- maxHeight?: string | undefined;
991
- triggerIndices?: number[] | "all" | "only-last" | undefined;
992
- alwaysShowScrollbar?: boolean | undefined;
993
- backButtonThreshold?: number | undefined;
994
- showBackButton?: boolean | undefined;
995
- backButtonPosition?: import("vue-element-plus-x/types/components/BubbleList/types").BackButtonPosition | undefined;
996
- btnLoading?: boolean | undefined;
997
- btnColor?: string | undefined;
998
- btnIconSize?: number | undefined;
999
- } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
1000
- expose(exposed: import("vue").ShallowUnwrapRef<{
1001
- scrollToTop: () => void;
1002
- scrollToBottom: () => void;
1003
- scrollToBubble: (index: number) => void;
1004
- }>): void;
1005
- attrs: any;
1006
- slots: {
1007
- avatar?(_: {
1008
- item: T_5;
1009
- }): any;
1010
- header?(_: {
1011
- item: T_5;
1012
- }): any;
1013
- content?(_: {
1014
- item: T_5;
1015
- }): any;
1016
- footer?(_: {
1017
- item: T_5;
1018
- }): any;
1019
- loading?(_: {
1020
- item: T_5;
1021
- }): any;
1022
- backToBottom?(_: {}): any;
1023
- };
1024
- emit: (event: "complete", ...args: any[]) => void;
1025
- } | undefined;
1026
- };
1027
- }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
1028
- items: {
1029
- type: {
1030
- (arrayLength: number): import("../../agent-chat-provider/src/types").BubbleItem[];
1031
- (...items: import("../../agent-chat-provider/src/types").BubbleItem[]): import("../../agent-chat-provider/src/types").BubbleItem[];
1032
- new (arrayLength: number): import("../../agent-chat-provider/src/types").BubbleItem[];
1033
- new (...items: import("../../agent-chat-provider/src/types").BubbleItem[]): import("../../agent-chat-provider/src/types").BubbleItem[];
1034
- isArray(arg: any): arg is any[];
1035
- readonly prototype: any[];
1036
- from<T>(arrayLike: ArrayLike<T>): T[];
1037
- from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
1038
- from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
1039
- from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
1040
- of<T_4>(...items: T_4[]): T_4[];
1041
- readonly [Symbol.species]: ArrayConstructor;
1042
- };
1043
- default: () => never[];
1044
- };
1045
- elRef: {
1046
- type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
1047
- default: import("@vunk/shared").AnyFunc;
1048
- };
1049
- textToSpeech: {
1050
- type: import("vue").PropType<import("./types").TextToSpeech>;
1051
- };
1052
- }>> & Readonly<{}>, {
1053
- items: import("../../agent-chat-provider/src/types").BubbleItem[];
1054
- elRef: import("@vunk/shared").AnyFunc;
1055
- }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
1056
- readonly VkRecorderButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
1057
- onTextZone: {
1058
- type: import("vue").PropType<import("../../recorder-button/src/types").OnTextZone>;
1059
- default: undefined;
1060
- };
1061
- appendTo: {
1062
- type: null;
1063
- default: string;
1064
- };
1065
- disabled: {
1066
- type: BooleanConstructor;
1067
- default: boolean;
1068
- };
1069
- speechToText: {
1070
- type: import("vue").PropType<import("./types").SpeechToText>;
1071
- default: undefined;
1072
- };
1073
- submitToText: {
1074
- type: BooleanConstructor;
1075
- default: boolean;
1076
- };
1077
- }>, {
1078
- onmousedown: (e: MouseEvent | TouchEvent) => void;
1079
- onmousemove: (e: MouseEvent | TouchEvent) => void;
1080
- onmouseup: (e: MouseEvent | TouchEvent) => void;
1081
- recording: import("vue").Ref<boolean, boolean>;
1082
- recordingNode: import("vue").Ref<HTMLSpanElement, HTMLSpanElement>;
1083
- blobUrl: import("vue").Ref<string, string>;
1084
- isDragging: import("vue").Ref<boolean, boolean>;
1085
- cancelZone: import("vue").Ref<boolean, boolean>;
1086
- isTextZone: import("vue").Ref<boolean, boolean>;
1087
- }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
1088
- submitText: (text: string) => boolean;
1089
- submit: (_: import("../../recorder-button/src/types").SubmitRawEvent) => boolean;
1090
- }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
1091
- onTextZone: {
1092
- type: import("vue").PropType<import("../../recorder-button/src/types").OnTextZone>;
1093
- default: undefined;
1094
- };
1095
- appendTo: {
1096
- type: null;
1097
- default: string;
1098
- };
1099
- disabled: {
1100
- type: BooleanConstructor;
1101
- default: boolean;
1102
- };
1103
- speechToText: {
1104
- type: import("vue").PropType<import("./types").SpeechToText>;
1105
- default: undefined;
1106
- };
1107
- submitToText: {
1108
- type: BooleanConstructor;
1109
- default: boolean;
1110
- };
1111
- }>> & Readonly<{
1112
- onSubmit?: ((_: import("../../recorder-button/src/types").SubmitRawEvent) => any) | undefined;
1113
- onSubmitText?: ((text: string) => any) | undefined;
1114
- }>, {
1115
- disabled: boolean;
1116
- onTextZone: import("../../recorder-button/src/types").OnTextZone;
1117
- appendTo: any;
1118
- speechToText: import("./types").SpeechToText;
1119
- submitToText: boolean;
1120
- }, {}, {
1121
- ElButton: import("element-plus/es/utils").SFCWithInstall<{
1122
- new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
1123
- readonly size: {
1124
- readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
1125
- readonly required: false;
1126
- readonly validator: ((val: unknown) => boolean) | undefined;
1127
- __epPropKey: true;
1128
- };
1129
- readonly disabled: BooleanConstructor;
1130
- readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown, "", boolean>;
1131
- readonly icon: {
1132
- readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
1133
- readonly required: false;
1134
- readonly validator: ((val: unknown) => boolean) | undefined;
1135
- __epPropKey: true;
1136
- };
1137
- readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
1138
- readonly loading: BooleanConstructor;
1139
- readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
1140
- readonly plain: BooleanConstructor;
1141
- readonly text: BooleanConstructor;
1142
- readonly link: BooleanConstructor;
1143
- readonly bg: BooleanConstructor;
1144
- readonly autofocus: BooleanConstructor;
1145
- readonly round: BooleanConstructor;
1146
- readonly circle: BooleanConstructor;
1147
- readonly color: StringConstructor;
1148
- readonly dark: BooleanConstructor;
1149
- readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1150
- readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
1151
- }>> & {
1152
- onClick?: ((evt: MouseEvent) => any) | undefined;
1153
- }, {
1154
- ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
1155
- size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
1156
- type: import("vue").ComputedRef<"" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger">;
1157
- disabled: import("vue").ComputedRef<boolean>;
1158
- shouldAddSpace: import("vue").ComputedRef<boolean>;
1159
- }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
1160
- click: (evt: MouseEvent) => void;
1161
- }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
1162
- readonly link: boolean;
1163
- readonly circle: boolean;
1164
- readonly text: boolean;
1165
- readonly disabled: boolean;
1166
- readonly round: boolean;
1167
- readonly dark: boolean;
1168
- readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown>;
1169
- readonly bg: boolean;
1170
- readonly loading: boolean;
1171
- readonly autofocus: boolean;
1172
- readonly tag: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
1173
- readonly nativeType: import("element-plus").ButtonType<StringConstructor, "button" | "reset" | "submit", unknown>;
1174
- readonly loadingIcon: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
1175
- readonly autoInsertSpace: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
1176
- readonly plain: boolean;
1177
- }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
1178
- P: {};
1179
- B: {};
1180
- D: {};
1181
- C: {};
1182
- M: {};
1183
- Defaults: {};
1184
- }, Readonly<import("vue").ExtractPropTypes<{
1185
- readonly size: {
1186
- readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
1187
- readonly required: false;
1188
- readonly validator: ((val: unknown) => boolean) | undefined;
1189
- __epPropKey: true;
1190
- };
1191
- readonly disabled: BooleanConstructor;
1192
- readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown, "", boolean>;
1193
- readonly icon: {
1194
- readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
1195
- readonly required: false;
1196
- readonly validator: ((val: unknown) => boolean) | undefined;
1197
- __epPropKey: true;
1198
- };
1199
- readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
1200
- readonly loading: BooleanConstructor;
1201
- readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
1202
- readonly plain: BooleanConstructor;
1203
- readonly text: BooleanConstructor;
1204
- readonly link: BooleanConstructor;
1205
- readonly bg: BooleanConstructor;
1206
- readonly autofocus: BooleanConstructor;
1207
- readonly round: BooleanConstructor;
1208
- readonly circle: BooleanConstructor;
1209
- readonly color: StringConstructor;
1210
- readonly dark: BooleanConstructor;
1211
- readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1212
- readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
1213
- }>> & {
1214
- onClick?: ((evt: MouseEvent) => any) | undefined;
1215
- }, {
1216
- ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
1217
- size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
1218
- type: import("vue").ComputedRef<"" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger">;
1219
- disabled: import("vue").ComputedRef<boolean>;
1220
- shouldAddSpace: import("vue").ComputedRef<boolean>;
1221
- }, {}, {}, {}, {
1222
- readonly link: boolean;
1223
- readonly circle: boolean;
1224
- readonly text: boolean;
1225
- readonly disabled: boolean;
1226
- readonly round: boolean;
1227
- readonly dark: boolean;
1228
- readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown>;
1229
- readonly bg: boolean;
1230
- readonly loading: boolean;
1231
- readonly autofocus: boolean;
1232
- readonly tag: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
1233
- readonly nativeType: import("element-plus").ButtonType<StringConstructor, "button" | "reset" | "submit", unknown>;
1234
- readonly loadingIcon: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
1235
- readonly autoInsertSpace: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
1236
- readonly plain: boolean;
1237
- }>;
1238
- __isFragment?: undefined;
1239
- __isTeleport?: undefined;
1240
- __isSuspense?: undefined;
1241
- } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
1242
- readonly size: {
1243
- readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
1244
- readonly required: false;
1245
- readonly validator: ((val: unknown) => boolean) | undefined;
1246
- __epPropKey: true;
1247
- };
1248
- readonly disabled: BooleanConstructor;
1249
- readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown, "", boolean>;
1250
- readonly icon: {
1251
- readonly type: import("vue").PropType<import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>>;
1195
+ }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
1196
+ readonly disableWidth: BooleanConstructor;
1197
+ readonly disableHeight: BooleanConstructor;
1198
+ readonly onResize: {
1199
+ readonly type: import("vue").PropType<(event: {
1200
+ height: number;
1201
+ width: number;
1202
+ }) => void>;
1252
1203
  readonly required: false;
1253
1204
  readonly validator: ((val: unknown) => boolean) | undefined;
1254
1205
  __epPropKey: true;
1255
1206
  };
1256
- readonly nativeType: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "button" | "reset" | "submit", unknown, "button", boolean>;
1257
- readonly loading: BooleanConstructor;
1258
- readonly loadingIcon: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, () => any, boolean>;
1259
- readonly plain: BooleanConstructor;
1260
- readonly text: BooleanConstructor;
1261
- readonly link: BooleanConstructor;
1262
- readonly bg: BooleanConstructor;
1263
- readonly autofocus: BooleanConstructor;
1264
- readonly round: BooleanConstructor;
1265
- readonly circle: BooleanConstructor;
1266
- readonly color: StringConstructor;
1267
- readonly dark: BooleanConstructor;
1268
- readonly autoInsertSpace: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
1269
- readonly tag: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown, "button", boolean>;
1270
- }>> & {
1271
- onClick?: ((evt: MouseEvent) => any) | undefined;
1272
- }, {
1273
- ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
1274
- size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
1275
- type: import("vue").ComputedRef<"" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger">;
1276
- disabled: import("vue").ComputedRef<boolean>;
1277
- shouldAddSpace: import("vue").ComputedRef<boolean>;
1278
- }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
1279
- click: (evt: MouseEvent) => void;
1280
- }, string, {
1281
- readonly link: boolean;
1282
- readonly circle: boolean;
1283
- readonly text: boolean;
1284
- readonly disabled: boolean;
1285
- readonly round: boolean;
1286
- readonly dark: boolean;
1287
- readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown>;
1288
- readonly bg: boolean;
1289
- readonly loading: boolean;
1290
- readonly autofocus: boolean;
1291
- readonly tag: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
1292
- readonly nativeType: import("element-plus").ButtonType<StringConstructor, "button" | "reset" | "submit", unknown>;
1293
- readonly loadingIcon: import("element-plus").ButtonType<(new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) | ((new (...args: any[]) => (string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>) & {}) | (() => string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>))[], unknown, unknown>;
1294
- readonly autoInsertSpace: import("element-plus").ButtonType<BooleanConstructor, unknown, unknown>;
1295
- readonly plain: boolean;
1296
- }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
1297
- $slots: {
1298
- loading?(_: {}): any;
1299
- icon?(_: {}): any;
1300
- default?(_: {}): any;
1207
+ }>>, {
1208
+ readonly disableWidth: boolean;
1209
+ readonly disableHeight: boolean;
1210
+ }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
1211
+ readonly BubbleList: <T_5 extends import("vue-element-plus-x/types/components/Bubble/types").BubbleProps>(__VLS_props: {
1212
+ readonly onComplete?: ((...args: any[]) => any) | undefined;
1213
+ list: T_5[];
1214
+ maxHeight?: string | undefined;
1215
+ triggerIndices?: number[] | "all" | "only-last" | undefined;
1216
+ alwaysShowScrollbar?: boolean | undefined;
1217
+ backButtonThreshold?: number | undefined;
1218
+ showBackButton?: boolean | undefined;
1219
+ backButtonPosition?: import("vue-element-plus-x/types/components/BubbleList/types").BackButtonPosition | undefined;
1220
+ btnLoading?: boolean | undefined;
1221
+ btnColor?: string | undefined;
1222
+ btnIconSize?: number | undefined;
1223
+ } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: {
1224
+ slots: {
1225
+ avatar?(_: {
1226
+ item: T_5;
1227
+ }): any;
1228
+ header?(_: {
1229
+ item: T_5;
1230
+ }): any;
1231
+ content?(_: {
1232
+ item: T_5;
1233
+ }): any;
1234
+ footer?(_: {
1235
+ item: T_5;
1236
+ }): any;
1237
+ loading?(_: {
1238
+ item: T_5;
1239
+ }): any;
1240
+ backToBottom?(_: {}): any;
1301
1241
  };
1302
- })> & {
1303
- ButtonGroup: {
1304
- new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
1305
- readonly size: {
1306
- readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
1307
- readonly required: false;
1308
- readonly validator: ((val: unknown) => boolean) | undefined;
1309
- __epPropKey: true;
1310
- };
1311
- readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown, "", boolean>;
1312
- }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, {
1313
- readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown>;
1314
- }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
1315
- P: {};
1316
- B: {};
1317
- D: {};
1318
- C: {};
1319
- M: {};
1320
- Defaults: {};
1321
- }, Readonly<import("vue").ExtractPropTypes<{
1322
- readonly size: {
1323
- readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
1324
- readonly required: false;
1325
- readonly validator: ((val: unknown) => boolean) | undefined;
1326
- __epPropKey: true;
1327
- };
1328
- readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown, "", boolean>;
1329
- }>>, {}, {}, {}, {}, {
1330
- readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown>;
1331
- }>;
1332
- __isFragment?: undefined;
1333
- __isTeleport?: undefined;
1334
- __isSuspense?: undefined;
1335
- } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
1336
- readonly size: {
1337
- readonly type: import("vue").PropType<import("element-plus").ButtonType<StringConstructor, "" | "small" | "default" | "large", never>>;
1338
- readonly required: false;
1339
- readonly validator: ((val: unknown) => boolean) | undefined;
1340
- __epPropKey: true;
1341
- };
1342
- readonly type: import("element-plus/es/utils").EpPropFinalized<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown, "", boolean>;
1343
- }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
1344
- readonly type: import("element-plus").ButtonType<StringConstructor, "" | "default" | "info" | "success" | "text" | "warning" | "primary" | "danger", unknown>;
1345
- }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
1346
- $slots: {
1347
- default?(_: {}): any;
1242
+ emit: (event: "complete", ...args: any[]) => void;
1243
+ attrs: any;
1244
+ } | undefined, __VLS_expose?: ((exposed: import("vue").ShallowUnwrapRef<{
1245
+ scrollToTop: () => void;
1246
+ scrollToBottom: () => void;
1247
+ scrollToBubble: (index: number) => void;
1248
+ }>) => void) | undefined, __VLS_setup?: Promise<{
1249
+ props: {
1250
+ readonly onComplete?: ((...args: any[]) => any) | undefined;
1251
+ list: T_5[];
1252
+ maxHeight?: string | undefined;
1253
+ triggerIndices?: number[] | "all" | "only-last" | undefined;
1254
+ alwaysShowScrollbar?: boolean | undefined;
1255
+ backButtonThreshold?: number | undefined;
1256
+ showBackButton?: boolean | undefined;
1257
+ backButtonPosition?: import("vue-element-plus-x/types/components/BubbleList/types").BackButtonPosition | undefined;
1258
+ btnLoading?: boolean | undefined;
1259
+ btnColor?: string | undefined;
1260
+ btnIconSize?: number | undefined;
1261
+ } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
1262
+ expose(exposed: import("vue").ShallowUnwrapRef<{
1263
+ scrollToTop: () => void;
1264
+ scrollToBottom: () => void;
1265
+ scrollToBubble: (index: number) => void;
1266
+ }>): void;
1267
+ attrs: any;
1268
+ slots: {
1269
+ avatar?(_: {
1270
+ item: T_5;
1271
+ }): any;
1272
+ header?(_: {
1273
+ item: T_5;
1274
+ }): any;
1275
+ content?(_: {
1276
+ item: T_5;
1277
+ }): any;
1278
+ footer?(_: {
1279
+ item: T_5;
1280
+ }): any;
1281
+ loading?(_: {
1282
+ item: T_5;
1283
+ }): any;
1284
+ backToBottom?(_: {}): any;
1285
+ };
1286
+ emit: (event: "complete", ...args: any[]) => void;
1287
+ }> | undefined) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
1288
+ [key: string]: any;
1289
+ }> & {
1290
+ __ctx?: {
1291
+ props: {
1292
+ readonly onComplete?: ((...args: any[]) => any) | undefined;
1293
+ list: T_5[];
1294
+ maxHeight?: string | undefined;
1295
+ triggerIndices?: number[] | "all" | "only-last" | undefined;
1296
+ alwaysShowScrollbar?: boolean | undefined;
1297
+ backButtonThreshold?: number | undefined;
1298
+ showBackButton?: boolean | undefined;
1299
+ backButtonPosition?: import("vue-element-plus-x/types/components/BubbleList/types").BackButtonPosition | undefined;
1300
+ btnLoading?: boolean | undefined;
1301
+ btnColor?: string | undefined;
1302
+ btnIconSize?: number | undefined;
1303
+ } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
1304
+ expose(exposed: import("vue").ShallowUnwrapRef<{
1305
+ scrollToTop: () => void;
1306
+ scrollToBottom: () => void;
1307
+ scrollToBubble: (index: number) => void;
1308
+ }>): void;
1309
+ attrs: any;
1310
+ slots: {
1311
+ avatar?(_: {
1312
+ item: T_5;
1313
+ }): any;
1314
+ header?(_: {
1315
+ item: T_5;
1316
+ }): any;
1317
+ content?(_: {
1318
+ item: T_5;
1319
+ }): any;
1320
+ footer?(_: {
1321
+ item: T_5;
1322
+ }): any;
1323
+ loading?(_: {
1324
+ item: T_5;
1325
+ }): any;
1326
+ backToBottom?(_: {}): any;
1348
1327
  };
1349
- });
1328
+ emit: (event: "complete", ...args: any[]) => void;
1329
+ } | undefined;
1350
1330
  };
1351
- }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
1331
+ }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
1332
+ items: {
1333
+ type: {
1334
+ (arrayLength: number): import("../../agent-chat-provider/src/types").BubbleItem[];
1335
+ (...items: import("../../agent-chat-provider/src/types").BubbleItem[]): import("../../agent-chat-provider/src/types").BubbleItem[];
1336
+ new (arrayLength: number): import("../../agent-chat-provider/src/types").BubbleItem[];
1337
+ new (...items: import("../../agent-chat-provider/src/types").BubbleItem[]): import("../../agent-chat-provider/src/types").BubbleItem[];
1338
+ isArray(arg: any): arg is any[];
1339
+ readonly prototype: any[];
1340
+ from<T>(arrayLike: ArrayLike<T>): T[];
1341
+ from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
1342
+ from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
1343
+ from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
1344
+ of<T_4>(...items: T_4[]): T_4[];
1345
+ readonly [Symbol.species]: ArrayConstructor;
1346
+ };
1347
+ default: () => never[];
1348
+ };
1349
+ elRef: {
1350
+ type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
1351
+ default: import("@vunk/shared").AnyFunc;
1352
+ };
1353
+ textToSpeech: {
1354
+ type: import("vue").PropType<import("./types").TextToSpeech>;
1355
+ };
1356
+ }>> & Readonly<{}>, {
1357
+ items: import("../../agent-chat-provider/src/types").BubbleItem[];
1358
+ elRef: import("@vunk/shared").AnyFunc;
1359
+ }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
1352
1360
  readonly VkSender: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
1353
1361
  fileList: {
1354
1362
  type: import("vue").PropType<import("ant-design-vue").UploadFile<any>[]>;
@@ -1383,6 +1391,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
1383
1391
  };
1384
1392
  default: () => never[];
1385
1393
  };
1394
+ sendDisabled: {
1395
+ type: BooleanConstructor;
1396
+ default: boolean;
1397
+ };
1386
1398
  }>, {
1387
1399
  hasAttachments: import("vue").ComputedRef<boolean>;
1388
1400
  actionsRender: (_: any, info: any) => JSX.Element;
@@ -1432,17 +1444,22 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
1432
1444
  };
1433
1445
  default: () => never[];
1434
1446
  };
1447
+ sendDisabled: {
1448
+ type: BooleanConstructor;
1449
+ default: boolean;
1450
+ };
1435
1451
  }>> & Readonly<{
1436
- onSubmit?: ((_: string) => any) | undefined;
1437
- onCancel?: ((...args: any[]) => any) | undefined;
1438
1452
  "onUpdate:modelValue"?: ((_: string) => any) | undefined;
1439
1453
  "onUpdate:fileList"?: ((_: import("ant-design-vue").UploadFile<any>[]) => any) | undefined;
1454
+ onSubmit?: ((_: string) => any) | undefined;
1455
+ onCancel?: ((...args: any[]) => any) | undefined;
1440
1456
  }>, {
1441
1457
  modules: "Attachments"[];
1442
- modelValue: string;
1443
1458
  loading: boolean;
1459
+ modelValue: string;
1444
1460
  action: string;
1445
1461
  fileList: import("ant-design-vue").UploadFile<any>[];
1462
+ sendDisabled: boolean;
1446
1463
  }, {}, {
1447
1464
  Sender: {
1448
1465
  new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("ant-design-x-vue").SenderProps> & Readonly<{