@blueking/ai-ui-sdk 0.4.0-beta.1 → 0.4.1-beta.1

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

@@ -0,0 +1,491 @@
+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, unref as _unref, resolveDirective as _resolveDirective, withDirectives as _withDirectives, openBlock as _openBlock, createElementBlock as _createElementBlock, createCommentVNode as _createCommentVNode, createElementVNode as _createElementVNode, createBlock as _createBlock, renderList as _renderList, Fragment as _Fragment, toDisplayString as _toDisplayString, normalizeClass as _normalizeClass } from "vue";
+const _hoisted_1 = {
+    class: "choose-space"
+};
+const _hoisted_2 = {
+    class: "g-flex-row g-items-center g-justify-center"
+};
+const _hoisted_3 = {
+    key: 0,
+    class: "bkaidev-icon bkaidev-prompt g-mr-4"
+};
+const _hoisted_4 = [
+    "onClick"
+];
+const _hoisted_5 = [
+    "data-ellipsis-tooltip"
+];
+const _hoisted_6 = {
+    class: "space-tool-number g-leading-16 g-text-gray"
+};
+import { ref, toRef, watch } from 'vue';
+import { MAX_PAGE_SIZE } from '../../common/constants.ts.js';
+import { isEmpty } from '../../common/util.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 { useToolHttp } from '../../hooks/use-tool-http.ts.js';
+import { FileStatus, GroupType, KnowledgebaseType, Module, ResourceStatus, SkillStatus } 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 spaces = ref([]);
+        const handleGetIsAllSpace = (spaceId)=>{
+            return spaceId === 'all';
+        };
+        // 空间全选状态
+        const handleGetIsSpaceAllChecked = (space)=>{
+            const spaceCount = space.count;
+            const spaceChoosenCount = handleGetSpaceChoosenResourcesCount(space.spaceId);
+            return spaceCount <= spaceChoosenCount && spaceCount !== 0;
+        };
+        const handleChooseSpace = (value)=>{
+            // 为空表示全部
+            const choosenSpace = handleGetIsAllSpace(value === null || value === void 0 ? void 0 : value.spaceId) ? undefined : value;
+            emits('update:choosenSpace', choosenSpace);
+        };
+        // 获取空间下选择的资源的数量
+        const handleGetSpaceChoosenResourcesCount = (spaceId)=>{
+            if (props.module === Module.Tool) {
+                return props.choosenTools.filter((tool)=>tool.status !== ResourceStatus.Deleted && (handleGetIsAllSpace(spaceId) || tool.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Mcp) {
+                return props.choosenMcps.filter((mcp)=>mcp.status !== ResourceStatus.Deleted && (handleGetIsAllSpace(spaceId) || mcp.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Knowledge) {
+                return props.choosenKnowledges.filter((knowledge)=>knowledge.status !== FileStatus.Deleted && (handleGetIsAllSpace(spaceId) || knowledge.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Knowledgebase) {
+                return props.choosenKnowledgebases.filter((knowledgebase)=>knowledgebase.status !== ResourceStatus.Deleted && (handleGetIsAllSpace(spaceId) || knowledgebase.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Agent) {
+                return props.choosenAgents.filter((agent)=>agent.status !== ResourceStatus.Deleted && (handleGetIsAllSpace(spaceId) || agent.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Collection) {
+                return props.choosenRoles.filter((role)=>role.status !== ResourceStatus.Deleted && (handleGetIsAllSpace(spaceId) || role.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Prompt) {
+                return props.choosenPrompts.filter((prompt)=>prompt.status !== ResourceStatus.Deleted && (handleGetIsAllSpace(spaceId) || prompt.spaceId === spaceId)).length;
+            }
+            if (props.module === Module.Skill) {
+                return props.choosenSkills.filter((skill)=>skill.status !== SkillStatus.Deleted && (handleGetIsAllSpace(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.canApply ? props.createdBy : undefined,
+                    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 handleGetResourceCount = ()=>{
+            const baseParam = {
+                spaceIds: [
+                    'all',
+                    ...spaces.value.map((space)=>space.spaceId)
+                ],
+                canApply: props.canApply,
+                withPrivate: false,
+                spaceName: props.spaceName,
+                groupType: GroupType.All,
+                createdBy: !props.canApply ? props.createdBy : undefined
+            };
+            const abortApiMap = {
+                [Module.Agent]: ()=>getAgentCount.abort(),
+                [Module.Knowledgebase]: ()=>getKnowledgebaseCount.abort(),
+                [Module.Knowledge]: ()=>getKnowledgeCount.abort(),
+                [Module.Mcp]: ()=>getMcpCount.abort(),
+                [Module.Tool]: ()=>getToolCount.abort(),
+                [Module.Prompt]: ()=>getPromptCount.abort(),
+                [Module.Collection]: ()=>getCollectionCount.abort(),
+                [Module.Skill]: ()=>getSkillCount.abort()
+            };
+            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,
+                        agentCode: props.agentCode
+                    })),
+                [Module.Tool]: ()=>getToolCount(baseParam),
+                [Module.Prompt]: ()=>getPromptCount(baseParam),
+                [Module.Collection]: ()=>getCollectionCount(baseParam),
+                [Module.Skill]: ()=>getSkillCount(baseParam)
+            };
+            const endLoading = startLoading();
+            abortApiMap[props.module]();
+            const api = apiMap[props.module];
+            api().then((data)=>{
+                spaces.value = data;
+            }).finally(endLoading);
+        };
+        const handleUpdateSpaceName = (val)=>{
+            emits('update:spaceName', val);
+        };
+        const handleUpdateCreatedBy = (val)=>{
+            emits('update:createdBy', val ? props.username : undefined);
+        };
+        watch([
+            ()=>props.spaceName,
+            ()=>props.module,
+            ()=>props.createdBy
+        ], 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-w-full g-mb-12",
+                    "model-value": !!props.createdBy,
+                    onChange: handleUpdateCreatedBy
+                }, {
+                    default: _withCtx(()=>[
+                            _createVNode(_component_bk_radio_button, {
+                                class: "!g-w-full",
+                                label: true
+                            }, {
+                                default: _withCtx(()=>[
+                                        ..._cache[0] || (_cache[0] = [
+                                            _createTextVNode("我的", -1 /* CACHED */ )
+                                        ])
+                                    ]),
+                                _: 1 /* STABLE */ 
+                            }),
+                            _createVNode(_component_bk_radio_button, {
+                                class: "!g-w-full",
+                                label: false
+                            }, {
+                                default: _withCtx(()=>[
+                                        _createElementVNode("span", _hoisted_2, [
+                                            props.module === _unref(Module).Mcp && !props.canApply ? _withDirectives((_openBlock(), _createElementBlock("i", _hoisted_3, null, 512 /* NEED_PATCH */ )), [
+                                                [
+                                                    _directive_bk_tooltips,
+                                                    {
+                                                        content: '包含所有可用的MCP（公开MCP、授权至当前空间的AIDEV来源MCP、授权至当前智能体的APIGW来源MCP）'
+                                                    }
+                                                ]
+                                            ]) : _createCommentVNode("v-if", true),
+                                            _cache[1] || (_cache[1] = _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(()=>[
+                            (_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 || handleGetIsAllSpace(space.spaceId) && _unref(isEmpty)(__props.choosenSpace)
+                                    }),
+                                    onClick: ($event)=>handleChooseSpace(space)
+                                }, [
+                                    __props.multiple ? _withDirectives((_openBlock(), _createBlock(RenderCheckbox, {
+                                        key: 0,
+                                        class: "g-mr-8",
+                                        disabled: handleGetIsAllSpace(space.spaceId),
+                                        checked: handleGetIsSpaceAllChecked(space),
+                                        onChange: (val)=>handleChooseSpaceResources(val, space.spaceId)
+                                    }, null, 8 /* PROPS */ , [
+                                        "disabled",
+                                        "checked",
+                                        "onChange"
+                                    ])), [
+                                        [
+                                            _directive_bk_tooltips,
+                                            {
+                                                content: '不支持全选所有',
+                                                placement: 'top',
+                                                disabled: !handleGetIsAllSpace(space.spaceId)
+                                            }
+                                        ]
+                                    ]) : _createCommentVNode("v-if", true),
+                                    _cache[3] || (_cache[3] = _createElementVNode("i", {
+                                        class: "ai-ui-sdk-icon ai-ui-sdk-benkongjiangongkai !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[2] || (_cache[2] = [
+                                                        _createTextVNode(" 本空间 ", -1 /* CACHED */ )
+                                                    ])
+                                                ]),
+                                            _: 1 /* STABLE */ 
+                                        })) : _createCommentVNode("v-if", true)
+                                    ], 8 /* PROPS */ , _hoisted_5),
+                                    _createElementVNode("span", _hoisted_6, _toDisplayString(space.count), 1 /* TEXT */ )
+                                ], 10 /* CLASS, PROPS */ , _hoisted_4);
+                            }), 128 /* KEYED_FRAGMENT */ ))
+                        ]),
+                    _: 1 /* STABLE */ 
+                }, 8 /* PROPS */ , [
+                    "loading"
+                ])
+            ]);
+        };
+    }
+});

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

@@ -0,0 +1,36 @@
+
+.choose-space[data-v-pyahlw5e] {
+  padding: 0 18px 0 24px;
+  height: 100%;
+  font-size: 12px;
+}
+.space-list[data-v-pyahlw5e] {
+  margin-top: 12px;
+  height: calc(100% - 44px);
+}
+.space-list .space-item[data-v-pyahlw5e] {
+    line-height: 32px;
+    padding-left: 8px;
+}
+.space-list .space-item[data-v-pyahlw5e]:hover {
+      background: #f5f7fa;
+}
+.space-list .space-item.space-item-active[data-v-pyahlw5e] {
+      background: #F0F5FF;
+      color: #3A84FF;
+}
+.space-list .space-item.space-item-active .space-tool-number[data-v-pyahlw5e] {
+        background: #A3C5FD;
+        color: #FFFFFF;
+}
+.space-list .space-item.space-item-active .bkaidev-guanlikongjian-3[data-v-pyahlw5e] {
+        color: #3A84FF;
+}
+.space-list .space-item.space-item-active .ai-ui-sdk-icon[data-v-pyahlw5e] {
+        color: #3A84FF;
+}
+.space-list .space-tool-number[data-v-pyahlw5e] {
+    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 type { IResourceCount } from '@/types/common';
+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 { ITool } from '@/types/tool';
+interface IProps {
+    choosenSpace?: IResourceCount;
+    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: IResourceCount) => 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: IResourceCount) => 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-pyahlw5e";
+script.__file = "./src/components/render-dialog/choose-space.vue";
+import './choose-space.vue.css';
+export default script;