npm - @blueking/ai-ui-sdk - Versions diffs - 0.1.12-beta.24 → 0.1.12-beta.26 - Mend

@blueking/ai-ui-sdk 0.1.12-beta.24 → 0.1.12-beta.26

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 (169) hide show

package/dist/hooks/use-chat.d.ts ADDED Viewed

@@ -0,0 +1,901 @@
+import { SessionContentRole, SessionContentStatus } from '../types/enum';
+import type { ChatCallbacks, ISession, ISessionContent, ISessionPrompt } from '../types/session';
+type SessionContentsMap = {
+    [key: string]: ISessionContent[];
+};
+type SessionLoadingMap = {
+    [key: string]: boolean;
+};
+export declare const useChat: ({ handleStart, handleText, handleReferenceDoc, handleThink, handleEnd, handleError, requestOptions, otherOptions, }: ChatCallbacks<ISessionContent>) => {
+    currentSession: import("vue").Ref<ISession, ISession>;
+    sessionContents: import("vue").Ref<{
+        id?: number;
+        createdAt?: string;
+        createdBy?: string;
+        updatedAt?: string;
+        updatedBy?: string;
+        spaceId?: string;
+        liked?: boolean;
+        role: SessionContentRole;
+        content: string;
+        rate?: number;
+        status?: SessionContentStatus;
+        sessionCode: string;
+        cite?: string;
+        time?: string;
+        property?: {
+            extra?: {
+                [x: string]: any;
+                tools?: {
+                    spaceId?: string;
+                    header: {
+                        name: string;
+                        required: boolean;
+                        type: import("../types/enum").ApiValueType;
+                        default: string | number | boolean;
+                        description: string;
+                        validate: {
+                            enable: boolean;
+                            rules: {
+                                func: string;
+                                message: string;
+                                value: string;
+                            }[];
+                        };
+                    }[];
+                    query?: {
+                        name: string;
+                        required: boolean;
+                        type: import("../types/enum").ApiValueType;
+                        default: string | number | boolean;
+                        description: string;
+                        validate: {
+                            enable: boolean;
+                            rules: {
+                                func: string;
+                                message: string;
+                                value: string;
+                            }[];
+                        };
+                    }[];
+                    body?: {
+                        name: string;
+                        required: boolean;
+                        type: import("../types/enum").ApiValueType;
+                        default: string | number | boolean;
+                        description: string;
+                        validate: {
+                            enable: boolean;
+                            rules: {
+                                func: string;
+                                message: string;
+                                value: string;
+                            }[];
+                        };
+                    }[];
+                    creator: string;
+                    createTime: string;
+                    updateTime: string;
+                    toolCode: string;
+                    toolName: string;
+                    icon: string;
+                    description: string;
+                    method: string;
+                    url: string;
+                    generateType: import("../types/enum").EnumCharacter;
+                    id?: number;
+                    status?: import("../types/enum").ResourceStatus;
+                    isSensitive?: boolean;
+                    permission?: {
+                        accessModel?: boolean;
+                        accessModelStrategy?: boolean;
+                        viewSpace?: boolean;
+                        manageSpace?: boolean;
+                        viewAgent?: boolean;
+                        createAgent?: boolean;
+                        manageAgent?: boolean;
+                        viewPrompt?: boolean;
+                        createPrompt?: boolean;
+                        managePrompt?: boolean;
+                        viewCollection?: boolean;
+                        createCollection?: boolean;
+                        manageCollection?: boolean;
+                        viewTool?: boolean;
+                        createTool?: boolean;
+                        manageTool?: boolean;
+                        viewKnowledgebase?: boolean;
+                        createKnowledgebase?: boolean;
+                        manageKnowledgebase?: boolean;
+                        viewQueryTemplate?: boolean;
+                        createQueryTemplate?: boolean;
+                        manageQueryTemplate?: boolean;
+                        viewDataset?: boolean;
+                        manageDataset?: boolean;
+                    };
+                    credentialId?: number;
+                    credentialType?: import("../types/enum").ToolCrdentialType;
+                    credentialLocation?: import("../types/enum").CrdentialLocation;
+                }[];
+                anchorPathResources?: {
+                    knowledges?: {
+                        id?: number;
+                        spaceId?: string;
+                        url?: string;
+                        content?: string;
+                        tagNames?: string[][];
+                        splitter?: string;
+                        handleType?: string[];
+                        updateFrequency?: number;
+                        headers?: Record<string, string>;
+                        csvDelimiter?: string;
+                        name: string;
+                        fileName?: string;
+                        fileSize?: number;
+                        fileType?: string;
+                        filePath?: string;
+                        pathType?: import("../types/enum").KnowledgePathType;
+                        createdType?: import("../types/enum").KnowledgeType;
+                        status?: import("../types/enum").FileStatus;
+                        knowledgebaseId?: number;
+                        knowledgebaseName?: string;
+                        parentAnchorPath?: string;
+                        permission?: {
+                            accessModel?: boolean;
+                            accessModelStrategy?: boolean;
+                            viewSpace?: boolean;
+                            manageSpace?: boolean;
+                            viewAgent?: boolean;
+                            createAgent?: boolean;
+                            manageAgent?: boolean;
+                            viewPrompt?: boolean;
+                            createPrompt?: boolean;
+                            managePrompt?: boolean;
+                            viewCollection?: boolean;
+                            createCollection?: boolean;
+                            manageCollection?: boolean;
+                            viewTool?: boolean;
+                            createTool?: boolean;
+                            manageTool?: boolean;
+                            viewKnowledgebase?: boolean;
+                            createKnowledgebase?: boolean;
+                            manageKnowledgebase?: boolean;
+                            viewQueryTemplate?: boolean;
+                            createQueryTemplate?: boolean;
+                            manageQueryTemplate?: boolean;
+                            viewDataset?: boolean;
+                            manageDataset?: boolean;
+                        };
+                        anchorPath?: string;
+                        linkFiles?: {
+                            name: string;
+                            handleType: string[];
+                            splitter: string;
+                            pathType: import("../types/enum").KnowledgePathType;
+                            csvDelimiter?: string;
+                            indexConfig?: {
+                                vector_indexes: {
+                                    index_name: string;
+                                    index_type: string;
+                                    status?: "normal" | "init" | "deleting";
+                                    index_config: {
+                                        type?: "user" | "system";
+                                        data_type?: string;
+                                        columns: string[];
+                                    };
+                                }[];
+                                scalar_indexes: {
+                                    index_name: string;
+                                    index_type: string;
+                                    status?: "normal" | "init" | "deleting";
+                                    index_config: {
+                                        type?: "user" | "system";
+                                        data_type?: string;
+                                        columns: string[];
+                                    };
+                                }[];
+                                full_text_indexes: {
+                                    index_name: string;
+                                    index_type: string;
+                                    status?: "normal" | "init" | "deleting";
+                                    index_config: {
+                                        type?: "user" | "system";
+                                        data_type?: string;
+                                        columns: string[];
+                                    };
+                                }[];
+                            };
+                            url: string;
+                            fileName: string;
+                            fileSize: number;
+                            fileType: string;
+                            linkType: import("../types/enum").FileLinkType;
+                            fileNumber?: number;
+                            id?: string;
+                            files?: {
+                                readonly lastModified: number;
+                                readonly name: string;
+                                readonly webkitRelativePath: string;
+                                readonly size: number;
+                                readonly type: string;
+                                arrayBuffer: () => Promise<ArrayBuffer>;
+                                bytes: () => Promise<Uint8Array>;
+                                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                                stream: () => ReadableStream<Uint8Array>;
+                                text: () => Promise<string>;
+                            }[];
+                            loadingPercentage?: number;
+                            headers?: Record<string, string>;
+                        }[];
+                        updatedAt?: string;
+                        updatedBy?: string;
+                        errorMessage?: string;
+                        isStructured?: boolean;
+                        credentialId?: number;
+                        indexConfig?: {
+                            vector_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            scalar_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            full_text_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                        };
+                    }[];
+                    knowledgebases?: {
+                        id?: number;
+                        knowledgebaseId?: number;
+                        knowledgebaseCode: string;
+                        spaceId?: string;
+                        anchorPath?: string;
+                        parentAnchorPath?: string;
+                        filePath: string;
+                        fileName?: string;
+                        fileType?: string;
+                        handleType?: string[];
+                        updateFrequency?: number;
+                        name: string;
+                        status?: import("../types/enum").ResourceStatus;
+                        generateType?: import("../types/enum").EnumCharacter;
+                        pathType?: import("../types/enum").KnowledgePathType;
+                        createdType?: import("../types/enum").KnowledgeType;
+                        number?: number;
+                        description?: string;
+                        folderNumber?: number;
+                        url?: string;
+                        updatedBy?: string;
+                        indexConfig?: {
+                            vector_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            scalar_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            full_text_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                        };
+                        permission?: {
+                            accessModel?: boolean;
+                            accessModelStrategy?: boolean;
+                            viewSpace?: boolean;
+                            manageSpace?: boolean;
+                            viewAgent?: boolean;
+                            createAgent?: boolean;
+                            manageAgent?: boolean;
+                            viewPrompt?: boolean;
+                            createPrompt?: boolean;
+                            managePrompt?: boolean;
+                            viewCollection?: boolean;
+                            createCollection?: boolean;
+                            manageCollection?: boolean;
+                            viewTool?: boolean;
+                            createTool?: boolean;
+                            manageTool?: boolean;
+                            viewKnowledgebase?: boolean;
+                            createKnowledgebase?: boolean;
+                            manageKnowledgebase?: boolean;
+                            viewQueryTemplate?: boolean;
+                            createQueryTemplate?: boolean;
+                            manageQueryTemplate?: boolean;
+                            viewDataset?: boolean;
+                            manageDataset?: boolean;
+                        };
+                        children?: /*elided*/ any[];
+                    }[];
+                    knowledgeFolders?: {
+                        id?: number;
+                        knowledgebaseId?: number;
+                        knowledgebaseCode: string;
+                        spaceId?: string;
+                        anchorPath?: string;
+                        parentAnchorPath?: string;
+                        filePath: string;
+                        fileName?: string;
+                        fileType?: string;
+                        handleType?: string[];
+                        updateFrequency?: number;
+                        name: string;
+                        status?: import("../types/enum").ResourceStatus;
+                        generateType?: import("../types/enum").EnumCharacter;
+                        pathType?: import("../types/enum").KnowledgePathType;
+                        createdType?: import("../types/enum").KnowledgeType;
+                        number?: number;
+                        description?: string;
+                        folderNumber?: number;
+                        url?: string;
+                        updatedBy?: string;
+                        indexConfig?: {
+                            vector_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            scalar_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            full_text_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                        };
+                        permission?: {
+                            accessModel?: boolean;
+                            accessModelStrategy?: boolean;
+                            viewSpace?: boolean;
+                            manageSpace?: boolean;
+                            viewAgent?: boolean;
+                            createAgent?: boolean;
+                            manageAgent?: boolean;
+                            viewPrompt?: boolean;
+                            createPrompt?: boolean;
+                            managePrompt?: boolean;
+                            viewCollection?: boolean;
+                            createCollection?: boolean;
+                            manageCollection?: boolean;
+                            viewTool?: boolean;
+                            createTool?: boolean;
+                            manageTool?: boolean;
+                            viewKnowledgebase?: boolean;
+                            createKnowledgebase?: boolean;
+                            manageKnowledgebase?: boolean;
+                            viewQueryTemplate?: boolean;
+                            createQueryTemplate?: boolean;
+                            manageQueryTemplate?: boolean;
+                            viewDataset?: boolean;
+                            manageDataset?: boolean;
+                        };
+                        children?: /*elided*/ any[];
+                    }[];
+                };
+            };
+        };
+    }[], ISessionContent[] | {
+        id?: number;
+        createdAt?: string;
+        createdBy?: string;
+        updatedAt?: string;
+        updatedBy?: string;
+        spaceId?: string;
+        liked?: boolean;
+        role: SessionContentRole;
+        content: string;
+        rate?: number;
+        status?: SessionContentStatus;
+        sessionCode: string;
+        cite?: string;
+        time?: string;
+        property?: {
+            extra?: {
+                [x: string]: any;
+                tools?: {
+                    spaceId?: string;
+                    header: {
+                        name: string;
+                        required: boolean;
+                        type: import("../types/enum").ApiValueType;
+                        default: string | number | boolean;
+                        description: string;
+                        validate: {
+                            enable: boolean;
+                            rules: {
+                                func: string;
+                                message: string;
+                                value: string;
+                            }[];
+                        };
+                    }[];
+                    query?: {
+                        name: string;
+                        required: boolean;
+                        type: import("../types/enum").ApiValueType;
+                        default: string | number | boolean;
+                        description: string;
+                        validate: {
+                            enable: boolean;
+                            rules: {
+                                func: string;
+                                message: string;
+                                value: string;
+                            }[];
+                        };
+                    }[];
+                    body?: {
+                        name: string;
+                        required: boolean;
+                        type: import("../types/enum").ApiValueType;
+                        default: string | number | boolean;
+                        description: string;
+                        validate: {
+                            enable: boolean;
+                            rules: {
+                                func: string;
+                                message: string;
+                                value: string;
+                            }[];
+                        };
+                    }[];
+                    creator: string;
+                    createTime: string;
+                    updateTime: string;
+                    toolCode: string;
+                    toolName: string;
+                    icon: string;
+                    description: string;
+                    method: string;
+                    url: string;
+                    generateType: import("../types/enum").EnumCharacter;
+                    id?: number;
+                    status?: import("../types/enum").ResourceStatus;
+                    isSensitive?: boolean;
+                    permission?: {
+                        accessModel?: boolean;
+                        accessModelStrategy?: boolean;
+                        viewSpace?: boolean;
+                        manageSpace?: boolean;
+                        viewAgent?: boolean;
+                        createAgent?: boolean;
+                        manageAgent?: boolean;
+                        viewPrompt?: boolean;
+                        createPrompt?: boolean;
+                        managePrompt?: boolean;
+                        viewCollection?: boolean;
+                        createCollection?: boolean;
+                        manageCollection?: boolean;
+                        viewTool?: boolean;
+                        createTool?: boolean;
+                        manageTool?: boolean;
+                        viewKnowledgebase?: boolean;
+                        createKnowledgebase?: boolean;
+                        manageKnowledgebase?: boolean;
+                        viewQueryTemplate?: boolean;
+                        createQueryTemplate?: boolean;
+                        manageQueryTemplate?: boolean;
+                        viewDataset?: boolean;
+                        manageDataset?: boolean;
+                    };
+                    credentialId?: number;
+                    credentialType?: import("../types/enum").ToolCrdentialType;
+                    credentialLocation?: import("../types/enum").CrdentialLocation;
+                }[];
+                anchorPathResources?: {
+                    knowledges?: {
+                        id?: number;
+                        spaceId?: string;
+                        url?: string;
+                        content?: string;
+                        tagNames?: string[][];
+                        splitter?: string;
+                        handleType?: string[];
+                        updateFrequency?: number;
+                        headers?: Record<string, string>;
+                        csvDelimiter?: string;
+                        name: string;
+                        fileName?: string;
+                        fileSize?: number;
+                        fileType?: string;
+                        filePath?: string;
+                        pathType?: import("../types/enum").KnowledgePathType;
+                        createdType?: import("../types/enum").KnowledgeType;
+                        status?: import("../types/enum").FileStatus;
+                        knowledgebaseId?: number;
+                        knowledgebaseName?: string;
+                        parentAnchorPath?: string;
+                        permission?: {
+                            accessModel?: boolean;
+                            accessModelStrategy?: boolean;
+                            viewSpace?: boolean;
+                            manageSpace?: boolean;
+                            viewAgent?: boolean;
+                            createAgent?: boolean;
+                            manageAgent?: boolean;
+                            viewPrompt?: boolean;
+                            createPrompt?: boolean;
+                            managePrompt?: boolean;
+                            viewCollection?: boolean;
+                            createCollection?: boolean;
+                            manageCollection?: boolean;
+                            viewTool?: boolean;
+                            createTool?: boolean;
+                            manageTool?: boolean;
+                            viewKnowledgebase?: boolean;
+                            createKnowledgebase?: boolean;
+                            manageKnowledgebase?: boolean;
+                            viewQueryTemplate?: boolean;
+                            createQueryTemplate?: boolean;
+                            manageQueryTemplate?: boolean;
+                            viewDataset?: boolean;
+                            manageDataset?: boolean;
+                        };
+                        anchorPath?: string;
+                        linkFiles?: {
+                            name: string;
+                            handleType: string[];
+                            splitter: string;
+                            pathType: import("../types/enum").KnowledgePathType;
+                            csvDelimiter?: string;
+                            indexConfig?: {
+                                vector_indexes: {
+                                    index_name: string;
+                                    index_type: string;
+                                    status?: "normal" | "init" | "deleting";
+                                    index_config: {
+                                        type?: "user" | "system";
+                                        data_type?: string;
+                                        columns: string[];
+                                    };
+                                }[];
+                                scalar_indexes: {
+                                    index_name: string;
+                                    index_type: string;
+                                    status?: "normal" | "init" | "deleting";
+                                    index_config: {
+                                        type?: "user" | "system";
+                                        data_type?: string;
+                                        columns: string[];
+                                    };
+                                }[];
+                                full_text_indexes: {
+                                    index_name: string;
+                                    index_type: string;
+                                    status?: "normal" | "init" | "deleting";
+                                    index_config: {
+                                        type?: "user" | "system";
+                                        data_type?: string;
+                                        columns: string[];
+                                    };
+                                }[];
+                            };
+                            url: string;
+                            fileName: string;
+                            fileSize: number;
+                            fileType: string;
+                            linkType: import("../types/enum").FileLinkType;
+                            fileNumber?: number;
+                            id?: string;
+                            files?: {
+                                readonly lastModified: number;
+                                readonly name: string;
+                                readonly webkitRelativePath: string;
+                                readonly size: number;
+                                readonly type: string;
+                                arrayBuffer: () => Promise<ArrayBuffer>;
+                                bytes: () => Promise<Uint8Array>;
+                                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                                stream: () => ReadableStream<Uint8Array>;
+                                text: () => Promise<string>;
+                            }[];
+                            loadingPercentage?: number;
+                            headers?: Record<string, string>;
+                        }[];
+                        updatedAt?: string;
+                        updatedBy?: string;
+                        errorMessage?: string;
+                        isStructured?: boolean;
+                        credentialId?: number;
+                        indexConfig?: {
+                            vector_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            scalar_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            full_text_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                        };
+                    }[];
+                    knowledgebases?: {
+                        id?: number;
+                        knowledgebaseId?: number;
+                        knowledgebaseCode: string;
+                        spaceId?: string;
+                        anchorPath?: string;
+                        parentAnchorPath?: string;
+                        filePath: string;
+                        fileName?: string;
+                        fileType?: string;
+                        handleType?: string[];
+                        updateFrequency?: number;
+                        name: string;
+                        status?: import("../types/enum").ResourceStatus;
+                        generateType?: import("../types/enum").EnumCharacter;
+                        pathType?: import("../types/enum").KnowledgePathType;
+                        createdType?: import("../types/enum").KnowledgeType;
+                        number?: number;
+                        description?: string;
+                        folderNumber?: number;
+                        url?: string;
+                        updatedBy?: string;
+                        indexConfig?: {
+                            vector_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            scalar_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            full_text_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                        };
+                        permission?: {
+                            accessModel?: boolean;
+                            accessModelStrategy?: boolean;
+                            viewSpace?: boolean;
+                            manageSpace?: boolean;
+                            viewAgent?: boolean;
+                            createAgent?: boolean;
+                            manageAgent?: boolean;
+                            viewPrompt?: boolean;
+                            createPrompt?: boolean;
+                            managePrompt?: boolean;
+                            viewCollection?: boolean;
+                            createCollection?: boolean;
+                            manageCollection?: boolean;
+                            viewTool?: boolean;
+                            createTool?: boolean;
+                            manageTool?: boolean;
+                            viewKnowledgebase?: boolean;
+                            createKnowledgebase?: boolean;
+                            manageKnowledgebase?: boolean;
+                            viewQueryTemplate?: boolean;
+                            createQueryTemplate?: boolean;
+                            manageQueryTemplate?: boolean;
+                            viewDataset?: boolean;
+                            manageDataset?: boolean;
+                        };
+                        children?: /*elided*/ any[];
+                    }[];
+                    knowledgeFolders?: {
+                        id?: number;
+                        knowledgebaseId?: number;
+                        knowledgebaseCode: string;
+                        spaceId?: string;
+                        anchorPath?: string;
+                        parentAnchorPath?: string;
+                        filePath: string;
+                        fileName?: string;
+                        fileType?: string;
+                        handleType?: string[];
+                        updateFrequency?: number;
+                        name: string;
+                        status?: import("../types/enum").ResourceStatus;
+                        generateType?: import("../types/enum").EnumCharacter;
+                        pathType?: import("../types/enum").KnowledgePathType;
+                        createdType?: import("../types/enum").KnowledgeType;
+                        number?: number;
+                        description?: string;
+                        folderNumber?: number;
+                        url?: string;
+                        updatedBy?: string;
+                        indexConfig?: {
+                            vector_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            scalar_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                            full_text_indexes: {
+                                index_name: string;
+                                index_type: string;
+                                status?: "normal" | "init" | "deleting";
+                                index_config: {
+                                    type?: "user" | "system";
+                                    data_type?: string;
+                                    columns: string[];
+                                };
+                            }[];
+                        };
+                        permission?: {
+                            accessModel?: boolean;
+                            accessModelStrategy?: boolean;
+                            viewSpace?: boolean;
+                            manageSpace?: boolean;
+                            viewAgent?: boolean;
+                            createAgent?: boolean;
+                            manageAgent?: boolean;
+                            viewPrompt?: boolean;
+                            createPrompt?: boolean;
+                            managePrompt?: boolean;
+                            viewCollection?: boolean;
+                            createCollection?: boolean;
+                            manageCollection?: boolean;
+                            viewTool?: boolean;
+                            createTool?: boolean;
+                            manageTool?: boolean;
+                            viewKnowledgebase?: boolean;
+                            createKnowledgebase?: boolean;
+                            manageKnowledgebase?: boolean;
+                            viewQueryTemplate?: boolean;
+                            createQueryTemplate?: boolean;
+                            manageQueryTemplate?: boolean;
+                            viewDataset?: boolean;
+                            manageDataset?: boolean;
+                        };
+                        children?: /*elided*/ any[];
+                    }[];
+                };
+            };
+        };
+    }[]>;
+    sessionContentsMap: SessionContentsMap;
+    sessionLoadingMap: import("vue").Ref<SessionLoadingMap, SessionLoadingMap>;
+    prompts: import("vue").ComputedRef<ISessionPrompt[]>;
+    currentSessionLoading: import("vue").ComputedRef<boolean>;
+    isLoadingSessionContents: import("vue").Ref<boolean, boolean>;
+    chat: ({ sessionCode, url, data, headers, }: {
+        sessionCode: string;
+        url?: string;
+        data?: Record<string, any>;
+        headers?: Record<string, string>;
+    }) => void;
+    stopChat: (sessionCode: string) => void;
+    plusSessionContent: (sessionCode: string, sessionContent: ISessionContent) => Promise<ISessionContent>;
+    updateSessionContent: (sessionContent: ISessionContent) => boolean;
+    getSessionContentById: (id: number, sessionCode: string) => ISessionContent;
+    getLastSessionContentBySessionCode: (sessionCode: string) => ISessionContent;
+    getSessionContentsBySessionCode: (sessionCode: string) => ISessionContent[];
+    setCurrentSession: (session?: ISession) => void;
+    setCurrentSessionChain: (session: ISession) => Promise<void>;
+    setSessionContents: (data: ISessionContent[]) => void;
+    deleteSessionContent: (sessionCode: string, contentId: number) => Promise<number>;
+    deleteSessionContents: (sessionCode: string, contentIds: number[]) => Promise<number>;
+    handleStartChat: (sessionCode: string) => Promise<void>;
+    handleErrorChat: (sessionCode: string, message: string, code?: string) => Promise<void>;
+    handleCompleteRole: (sessionCode: string, prompts: ISessionPrompt[]) => Promise<void>;
+    reGenerateChat: (sessionCode: string, sessionContent: ISessionContent, sessionIndex: number) => void;
+    reSendChat: (sessionCode: string, sessionContent: ISessionContent, sessionIndex: number) => Promise<void>;
+    deleteChat: (index: number, sessionCode: string) => void;
+    getAgentInfoApi: () => Promise<import("../types").IAgentInfo>;
+    clearSessionApi: (sessionCode: string) => Promise<unknown>;
+    getSessionsApi: () => Promise<ISession[]>;
+    plusSessionApi: (data: ISession) => Promise<ISession>;
+    modifySessionApi: (data: ISession) => Promise<ISession>;
+    deleteSessionApi: (sessionCode: string) => Promise<unknown>;
+    batchDeleteSessionsApi: (sessionCodes: string[]) => Promise<number>;
+    getSessionApi: (sessionCode: string) => Promise<ISession>;
+    getSessionContentsApi: (sessionCode: string) => Promise<ISessionContent[]>;
+    plusSessionContentApi: (data: ISessionContent) => Promise<ISessionContent>;
+    modifySessionContentApi: (data: ISessionContent) => Promise<ISessionContent>;
+    deleteSessionContentApi: (id: number) => Promise<ISessionContent>;
+    batchDeleteSessionContentsApi: (ids: number[]) => Promise<number>;
+    updateRequestOptions: (newOptions: Partial<typeof requestOptions>) => void;
+};
+export {};