@blueking/ai-ui-sdk 0.2.2 → 0.3.0-beta.2

package/dist/components/render-dialog/choose-space.script.vue.js.js

@@ -0,0 +1,512 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+import { defineComponent as _defineComponent } from 'vue';
+import { createTextVNode as _createTextVNode, resolveComponent as _resolveComponent, withCtx as _withCtx, createVNode as _createVNode, openBlock as _openBlock, createBlock as _createBlock, createCommentVNode as _createCommentVNode, unref as _unref, resolveDirective as _resolveDirective, withDirectives as _withDirectives, createElementVNode as _createElementVNode, toDisplayString as _toDisplayString, normalizeClass as _normalizeClass, renderList as _renderList, Fragment as _Fragment, createElementBlock as _createElementBlock } from "vue";
+const _hoisted_1 = {
+    class: "choose-space"
+};
+const _hoisted_2 = {
+    class: "space-tool-number g-learning-16 g-text-gray"
+};
+const _hoisted_3 = [
+    "onClick"
+];
+const _hoisted_4 = [
+    "data-ellipsis-tooltip"
+];
+const _hoisted_5 = {
+    class: "space-tool-number g-learning-16 g-text-gray"
+};
+import { ref, toRef, watch } from 'vue';
+import { MAX_PAGE_SIZE } from '../../common/constants.ts.js';
+import RenderCheckbox from '../render-checkbox/index.vue.js';
+import { useAgentHttp } from '../../hooks/use-agent-http.ts.js';
+import { useCollectionHttp } from '../../hooks/use-collection-http.ts.js';
+import { useKnowledgeHttp } from '../../hooks/use-knowledge-http.ts.js';
+import { useLoadingVersion } from '../../hooks/use-loading-version.ts.js';
+import { useMcpHttp } from '../../hooks/use-mcp-http.ts.js';
+import { usePromptHttp } from '../../hooks/use-prompt-http.ts.js';
+import { useSkillHttp } from '../../hooks/use-skill-http.ts.js';
+import { useSpaceHttp } from '../../hooks/use-space-http.ts.js';
+import { useToolHttp } from '../../hooks/use-tool-http.ts.js';
+import { FileStatus, GroupType, KnowledgebaseType, Module, ResourceStatus } from '../../types/enum.ts.js';
+export default /*@__PURE__*/ _defineComponent({
+    props: {
+        choosenSpace: {},
+        module: {},
+        choosenTools: {},
+        choosenMcps: {},
+        choosenKnowledges: {},
+        choosenKnowledgebases: {},
+        choosenAgents: {},
+        choosenRoles: {},
+        choosenPrompts: {},
+        choosenSkills: {},
+        agentId: {},
+        agentType: {},
+        canApply: {
+            type: Boolean
+        },
+        multiple: {
+            type: Boolean
+        },
+        spaceName: {},
+        createdBy: {},
+        agentCode: {},
+        spaceId: {},
+        username: {},
+        apiPrefix: {}
+    },
+    emits: [
+        "update:choosenSpace",
+        "update:choosenTools",
+        "update:choosenMcps",
+        "update:choosenKnowledges",
+        "update:choosenKnowledgebases",
+        "update:choosenAgents",
+        "update:choosenRoles",
+        "update:choosenPrompts",
+        "update:choosenSkills",
+        "update:spaceName",
+        "update:createdBy"
+    ],
+    setup (__props, { emit: __emit }) {
+        const props = __props;
+        const emits = __emit;
+        const { loading: isLoadingSpace, startLoading } = useLoadingVersion();
+        const { getAgentCount, getAgentList } = useAgentHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getCollectionCount, getCollections } = useCollectionHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getKnowledgebaseCount, getKnowledgeCount, getKnowledges, getKnowledgebases } = useKnowledgeHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getMcpCount, getMcpList } = useMcpHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getPromptCount, getPrompts } = usePromptHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getSkillCount, getSkillList } = useSkillHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getToolCount, getTools } = useToolHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const { getUsableSpaces } = useSpaceHttp(props.apiPrefix, toRef(props, 'spaceId'));
+        const spaces = ref([]);
+        const resourceCount = ref([]);
+        // 空间全选状态
+        const handleGetIsSpaceAllChecked = (countSpaceId, spaceId)=>{
+            const spaceCount = handleGetActiveTypeCount(countSpaceId);
+            const spaceChoosenCount = handleGetSpaceChoosenResourcesCount(spaceId);
+            return spaceCount <= spaceChoosenCount && spaceCount !== 0;
+        };
+        const handleChooseSpace = (value)=>{
+            emits('update:choosenSpace', value);
+        };
+        // 获取空间下资源的数量
+        const handleGetActiveTypeCount = (spaceId)=>{
+            var _resourceCount_value_find;
+            return ((_resourceCount_value_find = resourceCount.value.find((item)=>item.spaceId === spaceId)) === null || _resourceCount_value_find === void 0 ? void 0 : _resourceCount_value_find.count) || 0;
+        };
+        // 获取空间下选择的资源的数量
+        const handleGetSpaceChoosenResourcesCount = (spaceId)=>{
+            if (props.module === Module.Tool) {
+                return props.choosenTools.filter((tool)=>tool.status !== ResourceStatus.Deleted && (!spaceId || tool.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Mcp) {
+                return props.choosenMcps.filter((mcp)=>mcp.status !== ResourceStatus.Deleted && (!spaceId || mcp.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Knowledge) {
+                return props.choosenKnowledges.filter((knowledge)=>knowledge.status !== FileStatus.Deleted && (!spaceId || knowledge.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Knowledgebase) {
+                return props.choosenKnowledgebases.filter((knowledgebase)=>knowledgebase.status !== ResourceStatus.Deleted && (!spaceId || knowledgebase.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Agent) {
+                return props.choosenAgents.filter((agent)=>agent.status !== ResourceStatus.Deleted && (!spaceId || agent.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Collection) {
+                return props.choosenRoles.filter((role)=>role.status !== ResourceStatus.Deleted && (!spaceId || role.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Prompt) {
+                return props.choosenPrompts.filter((prompt)=>prompt.status !== ResourceStatus.Deleted && (!spaceId || prompt.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Skill) {
+                return props.choosenSkills.filter((skill)=>skill.status !== ResourceStatus.Deleted && (!spaceId || skill.spaceId === spaceId)).length;
+            }
+        };
+        // 勾选全部资源
+        const handleChooseSpaceResources = function() {
+            var _ref = _async_to_generator(function*(checked, spaceId) {
+                const getChoosenResult = (choosens, resources)=>{
+                    let choosenResult = [
+                        ...choosens
+                    ];
+                    if (checked) {
+                        // 全选
+                        resources.forEach((item)=>{
+                            if (!choosenResult.find((i)=>i.id === item.id)) {
+                                choosenResult.push(item);
+                            }
+                        });
+                    } else {
+                        // 取消全选
+                        choosenResult = choosenResult.filter((item)=>item.spaceId !== spaceId);
+                    }
+                    return choosenResult;
+                };
+                const commonParam = {
+                    spaceId,
+                    groupType: GroupType.All,
+                    canApply: props.canApply,
+                    createdBy: props.createdBy,
+                    page: 1,
+                    pageSize: MAX_PAGE_SIZE,
+                    withPrivate: false
+                };
+                // agent
+                if (props.module === Module.Agent) {
+                    const resources = yield getAgentList(_object_spread_props(_object_spread({}, commonParam), {
+                        agentType: props.agentType,
+                        excludeAgentId: props.agentId,
+                        isPublished: true
+                    }));
+                    const choosenResult = getChoosenResult(props.choosenAgents, resources.results);
+                    emits('update:choosenAgents', choosenResult);
+                }
+                // knowledge
+                if (props.module === Module.Knowledge) {
+                    const resources = yield getKnowledges(_object_spread({
+                        searchbox: {
+                            status: FileStatus.Uploaded
+                        },
+                        knowledgebaseType: KnowledgebaseType.IntentRecog,
+                        hiddenFolders: false
+                    }, commonParam));
+                    const choosenResult = getChoosenResult(props.choosenKnowledges, resources.results);
+                    emits('update:choosenKnowledges', choosenResult);
+                }
+                // knowledgebase
+                if (props.module === Module.Knowledgebase) {
+                    const response = yield getKnowledgebases(commonParam);
+                    const choosenResult = getChoosenResult(props.choosenKnowledgebases, response.results);
+                    emits('update:choosenKnowledgebases', choosenResult);
+                }
+                // mcp
+                if (props.module === Module.Mcp) {
+                    const response = yield getMcpList(_object_spread_props(_object_spread({}, commonParam), {
+                        agentCode: props.agentCode,
+                        withApigwMcp: !props.canApply
+                    }));
+                    const choosenResult = getChoosenResult(props.choosenMcps, response.results);
+                    emits('update:choosenMcps', choosenResult);
+                }
+                // tool
+                if (props.module === Module.Tool) {
+                    const response = yield getTools(commonParam);
+                    const choosenResult = getChoosenResult(props.choosenTools, response.results);
+                    emits('update:choosenTools', choosenResult);
+                }
+                // collection (role)
+                if (props.module === Module.Collection) {
+                    const resources = yield getCollections(commonParam);
+                    const choosenResult = getChoosenResult(props.choosenRoles, resources.results);
+                    emits('update:choosenRoles', choosenResult);
+                }
+                // prompt
+                if (props.module === Module.Prompt) {
+                    const response = yield getPrompts(commonParam);
+                    const choosenResult = getChoosenResult(props.choosenPrompts, response.results);
+                    emits('update:choosenPrompts', choosenResult);
+                }
+                // skill
+                if (props.module === Module.Skill) {
+                    const response = yield getSkillList(commonParam);
+                    const choosenResult = getChoosenResult(props.choosenSkills, response.results);
+                    emits('update:choosenSkills', choosenResult);
+                }
+            });
+            return function handleChooseSpaceResources(checked, spaceId) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+        const handleGetUsableSpaces = ()=>{
+            const endLoading = startLoading();
+            getUsableSpaces.abort();
+            return getUsableSpaces({
+                resourceType: props.module,
+                canApply: props.canApply,
+                spaceName: props.spaceName
+            }).then((data)=>{
+                // 当前空间置顶
+                const currentSpaceIndex = data.findIndex((item)=>item.spaceId === props.spaceId);
+                const currentSpace = data.splice(currentSpaceIndex, 1);
+                if (currentSpace.length) {
+                    data.unshift(currentSpace[0]);
+                }
+                // 赋值
+                spaces.value = data;
+            }).finally(endLoading);
+        };
+        // 获取资源数量
+        const handleGetResourceCount = ()=>{
+            const baseParam = {
+                spaceIds: [
+                    'all',
+                    ...spaces.value.map((space)=>space.spaceId)
+                ],
+                canApply: props.canApply,
+                withPrivate: false,
+                spaceName: props.spaceName,
+                groupType: GroupType.All,
+                createdBy: props.createdBy
+            };
+            const apiMap = {
+                [Module.Agent]: ()=>getAgentCount(_object_spread_props(_object_spread({}, baseParam), {
+                        excludeAgentId: props.agentId,
+                        agentType: props.agentType,
+                        isPublished: true
+                    })),
+                [Module.Knowledgebase]: ()=>getKnowledgebaseCount(baseParam),
+                [Module.Knowledge]: ()=>getKnowledgeCount(baseParam),
+                [Module.Mcp]: ()=>getMcpCount(_object_spread_props(_object_spread({}, baseParam), {
+                        withApigwMcp: !props.canApply
+                    })),
+                [Module.Tool]: ()=>getToolCount(baseParam),
+                [Module.Prompt]: ()=>getPromptCount(baseParam),
+                [Module.Collection]: ()=>getCollectionCount(baseParam),
+                [Module.Skill]: ()=>getSkillCount(baseParam)
+            };
+            const api = apiMap[props.module];
+            api().then((data)=>{
+                resourceCount.value = data;
+            });
+        };
+        const handleUpdateSpaceName = (val)=>{
+            emits('update:spaceName', val);
+        };
+        const handleUpdateCreatedBy = (val)=>{
+            emits('update:createdBy', val ? props.username : undefined);
+        };
+        watch([
+            ()=>props.spaceName,
+            ()=>props.module,
+            ()=>props.createdBy
+        ], /*#__PURE__*/ _async_to_generator(function*() {
+            yield handleGetUsableSpaces();
+            yield handleGetResourceCount();
+        }), {
+            immediate: true
+        });
+        return (_ctx, _cache)=>{
+            const _component_bk_radio_button = _resolveComponent("bk-radio-button");
+            const _component_bk_radio_group = _resolveComponent("bk-radio-group");
+            const _component_bk_input = _resolveComponent("bk-input");
+            const _component_bk_tag = _resolveComponent("bk-tag");
+            const _component_bk_loading = _resolveComponent("bk-loading");
+            const _directive_bk_tooltips = _resolveDirective("bk-tooltips");
+            return _openBlock(), _createElementBlock("section", _hoisted_1, [
+                !__props.canApply ? (_openBlock(), _createBlock(_component_bk_radio_group, {
+                    key: 0,
+                    type: "capsule",
+                    class: "g-width-full g-mb-12",
+                    "model-value": !!props.createdBy,
+                    onChange: handleUpdateCreatedBy
+                }, {
+                    default: _withCtx(()=>[
+                            _createVNode(_component_bk_radio_button, {
+                                class: "g-width-full",
+                                label: true
+                            }, {
+                                default: _withCtx(()=>[
+                                        ..._cache[1] || (_cache[1] = [
+                                            _createTextVNode("我的", -1 /* CACHED */ )
+                                        ])
+                                    ]),
+                                _: 1 /* STABLE */ 
+                            }),
+                            _createVNode(_component_bk_radio_button, {
+                                class: "g-width-full",
+                                label: false
+                            }, {
+                                default: _withCtx(()=>[
+                                        ..._cache[2] || (_cache[2] = [
+                                            _createTextVNode("全部", -1 /* CACHED */ )
+                                        ])
+                                    ]),
+                                _: 1 /* STABLE */ 
+                            })
+                        ]),
+                    _: 1 /* STABLE */ 
+                }, 8 /* PROPS */ , [
+                    "model-value"
+                ])) : _createCommentVNode("v-if", true),
+                _createVNode(_component_bk_input, {
+                    clearable: "",
+                    type: "search",
+                    placeholder: "搜索空间关键字",
+                    "model-value": __props.spaceName,
+                    "onUpdate:modelValue": handleUpdateSpaceName
+                }, null, 8 /* PROPS */ , [
+                    "model-value"
+                ]),
+                _createVNode(_component_bk_loading, {
+                    loading: _unref(isLoadingSpace),
+                    class: "space-list g-scrollbar"
+                }, {
+                    default: _withCtx(()=>{
+                        var __props_choosenSpace;
+                        return [
+                            _createElementVNode("li", {
+                                class: _normalizeClass({
+                                    'space-item g-flex-row g-cursor-pointer': true,
+                                    'space-item-active': !((__props_choosenSpace = __props.choosenSpace) === null || __props_choosenSpace === void 0 ? void 0 : __props_choosenSpace.spaceId)
+                                }),
+                                onClick: _cache[0] || (_cache[0] = ($event)=>handleChooseSpace())
+                            }, [
+                                __props.multiple ? _withDirectives((_openBlock(), _createBlock(RenderCheckbox, {
+                                    key: 0,
+                                    class: "g-mr-8",
+                                    disabled: true,
+                                    checked: handleGetIsSpaceAllChecked('all')
+                                }, null, 8 /* PROPS */ , [
+                                    "checked"
+                                ])), [
+                                    [
+                                        _directive_bk_tooltips,
+                                        {
+                                            content: '不支持全选所有',
+                                            placement: 'top'
+                                        }
+                                    ]
+                                ]) : _createCommentVNode("v-if", true),
+                                _cache[3] || (_cache[3] = _createElementVNode("i", {
+                                    class: "bkaidev-icon bkaidev-quanbu-xuanzhong g-text-20 g-text-light-gray"
+                                }, null, -1 /* CACHED */ )),
+                                _cache[4] || (_cache[4] = _createElementVNode("span", {
+                                    class: "space-name g-flex-truncate g-ml-8"
+                                }, " 全部 ", -1 /* CACHED */ )),
+                                _createElementVNode("span", _hoisted_2, _toDisplayString(handleGetActiveTypeCount('all')), 1 /* TEXT */ )
+                            ], 2 /* CLASS */ ),
+                            (_openBlock(true), _createElementBlock(_Fragment, null, _renderList(spaces.value, (space)=>{
+                                var __props_choosenSpace;
+                                return _openBlock(), _createElementBlock("li", {
+                                    key: space.spaceId,
+                                    class: _normalizeClass({
+                                        'space-item g-flex-row g-cursor-pointer': true,
+                                        'space-item-active': ((__props_choosenSpace = __props.choosenSpace) === null || __props_choosenSpace === void 0 ? void 0 : __props_choosenSpace.spaceId) === space.spaceId
+                                    }),
+                                    onClick: ($event)=>handleChooseSpace(space)
+                                }, [
+                                    __props.multiple ? (_openBlock(), _createBlock(RenderCheckbox, {
+                                        key: 0,
+                                        class: "g-mr-8",
+                                        checked: handleGetIsSpaceAllChecked(space.spaceId, space.spaceId),
+                                        onChange: (val)=>handleChooseSpaceResources(val, space.spaceId)
+                                    }, null, 8 /* PROPS */ , [
+                                        "checked",
+                                        "onChange"
+                                    ])) : _createCommentVNode("v-if", true),
+                                    _cache[6] || (_cache[6] = _createElementVNode("i", {
+                                        class: "bkaidev-icon bkaidev-guanlikongjian-3 g-text-18 g-text-light-gray"
+                                    }, null, -1 /* CACHED */ )),
+                                    _createElementVNode("span", {
+                                        class: "space-name g-flex-truncate g-ml-8",
+                                        "data-ellipsis-tooltip": space.spaceName
+                                    }, [
+                                        _createTextVNode(_toDisplayString(space.spaceName) + " ", 1 /* TEXT */ ),
+                                        space.spaceId === props.spaceId ? (_openBlock(), _createBlock(_component_bk_tag, {
+                                            key: 0,
+                                            size: "small",
+                                            theme: "info"
+                                        }, {
+                                            default: _withCtx(()=>[
+                                                    ..._cache[5] || (_cache[5] = [
+                                                        _createTextVNode(" 本空间 ", -1 /* CACHED */ )
+                                                    ])
+                                                ]),
+                                            _: 1 /* STABLE */ 
+                                        })) : _createCommentVNode("v-if", true)
+                                    ], 8 /* PROPS */ , _hoisted_4),
+                                    _createElementVNode("span", _hoisted_5, _toDisplayString(handleGetActiveTypeCount(space.spaceId)), 1 /* TEXT */ )
+                                ], 10 /* CLASS, PROPS */ , _hoisted_3);
+                            }), 128 /* KEYED_FRAGMENT */ ))
+                        ];
+                    }),
+                    _: 1 /* STABLE */ 
+                }, 8 /* PROPS */ , [
+                    "loading"
+                ])
+            ]);
+        };
+    }
+});

package/dist/components/render-dialog/choose-space.vue.css

@@ -0,0 +1,33 @@
+
+.choose-space[data-v-wcizot0s] {
+  padding: 0 18px 0 24px;
+  height: 100%;
+  font-size: 12px;
+}
+.space-list[data-v-wcizot0s] {
+  margin-top: 12px;
+  height: calc(100% - 44px);
+}
+.space-list .space-item[data-v-wcizot0s] {
+    line-height: 32px;
+    padding-left: 8px;
+}
+.space-list .space-item[data-v-wcizot0s]:hover {
+      background: #f5f7fa;
+}
+.space-list .space-item.space-item-active[data-v-wcizot0s] {
+      background: #F0F5FF;
+      color: #3A84FF;
+}
+.space-list .space-item.space-item-active .space-tool-number[data-v-wcizot0s] {
+        background: #A3C5FD;
+        color: #FFFFFF;
+}
+.space-list .space-item.space-item-active .bkaidev-guanlikongjian-3[data-v-wcizot0s] {
+        color: #3A84FF;
+}
+.space-list .space-tool-number[data-v-wcizot0s] {
+    padding: 0 6px;
+    border-radius: 2px;
+    background: #F0F1F5;
+}

package/dist/components/render-dialog/choose-space.vue.d.ts

@@ -0,0 +1,58 @@
+import type { IAgent } from '@/types/agent';
+import type { ICollection } from '@/types/collection';
+import { AgentType, Module } from '@/types/enum';
+import type { IKnowledge, IKnowledgebase } from '@/types/knowledge';
+import type { IMcp } from '@/types/mcp';
+import type { IPrompt } from '@/types/prompt';
+import type { ISkill } from '@/types/skill';
+import type { IUsableSpace } from '@/types/space';
+import type { ITool } from '@/types/tool';
+interface IProps {
+    choosenSpace?: IUsableSpace;
+    module: Module;
+    choosenTools: ITool[];
+    choosenMcps: IMcp[];
+    choosenKnowledges: IKnowledge[];
+    choosenKnowledgebases: IKnowledgebase[];
+    choosenAgents: IAgent[];
+    choosenRoles: ICollection[];
+    choosenPrompts: IPrompt[];
+    choosenSkills: ISkill[];
+    agentId: number;
+    agentType?: AgentType;
+    canApply?: boolean;
+    multiple?: boolean;
+    spaceName?: string;
+    createdBy?: string;
+    agentCode?: string;
+    spaceId?: string;
+    username: string;
+    apiPrefix: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<IProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "update:choosenTools": (value: ITool[]) => any;
+    "update:choosenMcps": (value: IMcp[]) => any;
+    "update:choosenKnowledges": (value: IKnowledge[]) => any;
+    "update:choosenKnowledgebases": (value: IKnowledgebase[]) => any;
+    "update:choosenAgents": (value: IAgent[]) => any;
+    "update:choosenRoles": (value: ICollection[]) => any;
+    "update:choosenPrompts": (value: IPrompt[]) => any;
+    "update:choosenSkills": (value: ISkill[]) => any;
+    "update:choosenSpace": (value: IUsableSpace) => any;
+    "update:spaceName": (value: string) => any;
+    "update:createdBy": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<IProps> & Readonly<{
+    "onUpdate:choosenTools"?: (value: ITool[]) => any;
+    "onUpdate:choosenMcps"?: (value: IMcp[]) => any;
+    "onUpdate:choosenKnowledges"?: (value: IKnowledge[]) => any;
+    "onUpdate:choosenKnowledgebases"?: (value: IKnowledgebase[]) => any;
+    "onUpdate:choosenAgents"?: (value: IAgent[]) => any;
+    "onUpdate:choosenRoles"?: (value: ICollection[]) => any;
+    "onUpdate:choosenPrompts"?: (value: IPrompt[]) => any;
+    "onUpdate:choosenSkills"?: (value: ISkill[]) => any;
+    "onUpdate:choosenSpace"?: (value: IUsableSpace) => any;
+    "onUpdate:spaceName"?: (value: string) => any;
+    "onUpdate:createdBy"?: (value: string) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/render-dialog/choose-space.vue.js

@@ -0,0 +1,5 @@
+import script from './choose-space.script.vue.js.js';
+script.__scopeId = "data-v-wcizot0s";
+script.__file = "./src/components/render-dialog/choose-space.vue";
+import './choose-space.vue.css';
+export default script;