@meistrari/chat-nuxt 1.0.0

package/dist/runtime/composables/useWorkspaceCredentials.js

@@ -0,0 +1,175 @@
+import * as Sentry from "@sentry/nuxt";
+import { formatAbsoluteDate } from "../utils/format-time.js";
+export function useWorkspaceCredentials(searchQuery) {
+  const credentials = useState("workspace-credentials", () => []);
+  const loading = useState("workspace-credentials-loading", () => false);
+  const showCreateModal = ref(false);
+  const editingCredential = ref(null);
+  const deletingCredential = ref(null);
+  const credentialForm = ref({ key: "", value: "" });
+  const credentialSaving = ref(false);
+  const credentialError = ref("");
+  const credentialDeleting = ref(false);
+  async function fetchCredentials() {
+    loading.value = true;
+    try {
+      const data = await $fetch("/api/workspace/credentials");
+      credentials.value = data ?? [];
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function createCredential(payload) {
+    try {
+      const data = await $fetch("/api/workspace/credentials", {
+        method: "POST",
+        body: payload
+      });
+      credentials.value = [...credentials.value, data].sort((a, b) => a.key.localeCompare(b.key));
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      throw e;
+    }
+  }
+  async function updateCredential(id, payload) {
+    try {
+      const data = await $fetch(`/api/workspace/credentials/${id}`, {
+        method: "PUT",
+        body: payload
+      });
+      credentials.value = credentials.value.map((s) => s.id === id ? data : s);
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      throw e;
+    }
+  }
+  async function deleteCredential(id) {
+    try {
+      await $fetch(`/api/workspace/credentials/${id}`, { method: "DELETE" });
+      credentials.value = credentials.value.filter((s) => s.id !== id);
+    } catch (e) {
+      Sentry.captureException(e);
+      throw e;
+    }
+  }
+  const filteredCredentials = computed(() => {
+    const query = searchQuery?.value?.trim().toLowerCase();
+    if (!query)
+      return credentials.value;
+    return credentials.value.filter(
+      (s) => s.key.toLowerCase().includes(query)
+    );
+  });
+  const credentialModalOpen = computed({
+    get: () => showCreateModal.value || !!editingCredential.value,
+    set: (val) => {
+      if (!val) {
+        showCreateModal.value = false;
+        editingCredential.value = null;
+      }
+    }
+  });
+  const deleteModalOpen = computed({
+    get: () => !!deletingCredential.value,
+    set: (val) => {
+      if (!val)
+        deletingCredential.value = null;
+    }
+  });
+  function openCreateModal() {
+    credentialForm.value = { key: "", value: "" };
+    credentialError.value = "";
+    showCreateModal.value = true;
+  }
+  function openEditModal(credential) {
+    editingCredential.value = credential;
+    credentialForm.value = { key: credential.key, value: "" };
+    credentialError.value = "";
+  }
+  function closeModal() {
+    showCreateModal.value = false;
+    editingCredential.value = null;
+  }
+  async function handleSave() {
+    credentialError.value = "";
+    if (editingCredential.value && !credentialForm.value.value) {
+      closeModal();
+      return;
+    }
+    credentialSaving.value = true;
+    const statusToast = useStatusToast();
+    try {
+      if (editingCredential.value) {
+        await updateCredential(editingCredential.value.id, { value: credentialForm.value.value });
+        statusToast.update({ text: "Credencial atualizada", icon: "i-ph-check" });
+      } else {
+        await createCredential(credentialForm.value);
+        statusToast.update({ text: "Credencial criada", icon: "i-ph-check" });
+      }
+      closeModal();
+    } catch (error) {
+      credentialError.value = error?.data?.statusMessage ?? "Erro ao salvar credencial";
+    } finally {
+      credentialSaving.value = false;
+    }
+  }
+  async function handleDelete() {
+    if (!deletingCredential.value)
+      return;
+    credentialDeleting.value = true;
+    const statusToast = useStatusToast();
+    try {
+      await deleteCredential(deletingCredential.value.id);
+      statusToast.update({ text: "Credencial exclu\xEDda", icon: "i-ph-check" });
+      deletingCredential.value = null;
+    } catch (e) {
+      Sentry.captureException(e);
+      statusToast.update({ text: "Erro ao excluir credencial", icon: "i-ph-warning" });
+    } finally {
+      credentialDeleting.value = false;
+    }
+  }
+  function getMenuItems(credential) {
+    return [
+      { label: "Editar", icon: "i-ph-pencil-simple", click: () => openEditModal(credential) },
+      { label: "Excluir", icon: "i-ph-trash", click: () => {
+        deletingCredential.value = credential;
+      } }
+    ];
+  }
+  function formatLastRotated(updatedAt, createdAt) {
+    if (updatedAt === createdAt)
+      return "Nunca";
+    return formatAbsoluteDate(updatedAt);
+  }
+  return {
+    credentials: readonly(credentials),
+    loading: readonly(loading),
+    fetchCredentials,
+    createCredential,
+    updateCredential,
+    deleteCredential,
+    filteredCredentials,
+    credentialModalOpen,
+    deleteModalOpen,
+    credentialForm,
+    credentialSaving,
+    credentialDeleting,
+    credentialError,
+    editingCredential: readonly(editingCredential),
+    deletingCredential: readonly(deletingCredential),
+    openCreateModal,
+    openEditModal,
+    closeModal,
+    handleSave,
+    handleDelete,
+    getMenuItems,
+    formatLastRotated
+  };
+}

package/dist/runtime/composables/useWorkspaceExternalSkills.d.ts

@@ -0,0 +1,22 @@
+import type { ExternalSkill } from '../server/db/schema.js';
+export declare function useWorkspaceExternalSkills(searchQuery?: Ref<string>): {
+    displayedSkills: any;
+    filteredSkills: any;
+    hasChanges: any;
+    isPending: (ref: string) => boolean;
+    addSkill: (skill: ExternalSkill) => void;
+    removeSkill: (ref: string) => void;
+    buildExternalSkills: () => ExternalSkill[] | null;
+    initialize: () => void;
+    skillModalOpen: any;
+    skillRefInput: any;
+    skillError: any;
+    discoveringSkills: any;
+    handleAddSkill: () => Promise<void>;
+    closeSkillModal: () => void;
+    handleAddSkillAndClose: () => Promise<void>;
+    getGitHubButtonText: () => string;
+    skillsConnection: any;
+    fetchGitHubConnection: any;
+    connectGitHub: any;
+};

package/dist/runtime/composables/useWorkspaceExternalSkills.js

@@ -0,0 +1,135 @@
+export function useWorkspaceExternalSkills(searchQuery) {
+  const { settings } = useWorkspaceSettings();
+  const { user } = useTelaApplicationAuth();
+  const { connection: skillsConnection, fetchConnection: fetchGitHubConnection, connect: connectGitHub } = useGitHubSkills();
+  const pendingSkills = useState("workspace-external-skills-pending", () => []);
+  const removedRefs = useState("workspace-external-skills-removed", () => []);
+  const skillModalOpen = ref(false);
+  const skillRefInput = ref("");
+  const skillError = ref("");
+  const discoveringSkills = ref(false);
+  const displayedSkills = computed(() => {
+    const current = (settings.value?.externalSkills ?? []).filter((s) => !removedRefs.value.includes(s.ref));
+    return [...current, ...pendingSkills.value];
+  });
+  const filteredSkills = computed(() => {
+    const query = searchQuery?.value?.trim().toLowerCase();
+    if (!query)
+      return displayedSkills.value;
+    return displayedSkills.value.filter(
+      (skill) => skill.name.toLowerCase().includes(query) || skill.ref.toLowerCase().includes(query)
+    );
+  });
+  const hasChanges = computed(() => {
+    return pendingSkills.value.length > 0 || removedRefs.value.length > 0;
+  });
+  function isPending(ref2) {
+    return pendingSkills.value.some((s) => s.ref === ref2);
+  }
+  function addSkill(skill) {
+    pendingSkills.value = [...pendingSkills.value, skill];
+  }
+  function removeSkill(ref2) {
+    const pendingIndex = pendingSkills.value.findIndex((s) => s.ref === ref2);
+    if (pendingIndex !== -1) {
+      pendingSkills.value = pendingSkills.value.filter((_, i) => i !== pendingIndex);
+      return;
+    }
+    removedRefs.value = [...removedRefs.value, ref2];
+  }
+  function buildExternalSkills() {
+    const currentSkills = (settings.value?.externalSkills ?? []).filter((s) => !removedRefs.value.includes(s.ref)).map((s) => ({
+      ...s,
+      allowedTools: [...s.allowedTools],
+      addedBy: { ...s.addedBy }
+    }));
+    const finalSkills = [...currentSkills, ...pendingSkills.value];
+    return finalSkills.length > 0 ? finalSkills : null;
+  }
+  async function handleAddSkill() {
+    const inputRef = skillRefInput.value.trim();
+    if (!inputRef || discoveringSkills.value)
+      return;
+    skillError.value = "";
+    discoveringSkills.value = true;
+    try {
+      const metadata = await $fetch("/api/external-skills/discover", {
+        method: "POST",
+        body: { ref: inputRef }
+      });
+      const canonicalRef = metadata.ref;
+      if (displayedSkills.value.some((s) => s.ref === canonicalRef)) {
+        skillError.value = "Esta skill j\xE1 foi adicionada";
+        return;
+      }
+      const newSkill = {
+        ref: canonicalRef,
+        name: metadata.name,
+        description: metadata.description || "",
+        runtime: metadata.runtime || "unknown",
+        allowedTools: metadata.allowedTools || [],
+        isPublic: metadata.isPublic,
+        addedBy: {
+          userId: user.value?.id || "",
+          username: user.value?.name || skillsConnection.value.accountName || ""
+        },
+        addedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      addSkill(newSkill);
+      skillRefInput.value = "";
+    } catch (error) {
+      if (error.statusCode === 401)
+        skillError.value = "Reposit\xF3rio privado. Conecte um provedor para acessar.";
+      else if (error.statusCode === 404)
+        skillError.value = "Skill n\xE3o encontrada. Verifique se o caminho cont\xE9m um arquivo SKILL.md";
+      else
+        skillError.value = error.statusMessage || "Erro ao buscar skill";
+    } finally {
+      discoveringSkills.value = false;
+    }
+  }
+  function closeSkillModal() {
+    skillModalOpen.value = false;
+    skillRefInput.value = "";
+    skillError.value = "";
+  }
+  async function handleAddSkillAndClose() {
+    await handleAddSkill();
+    if (!skillError.value)
+      closeSkillModal();
+  }
+  function getGitHubButtonText() {
+    if (skillsConnection.value.connected)
+      return "Gerenciar GitHub";
+    return "Conectar GitHub";
+  }
+  function initialize() {
+    pendingSkills.value = [];
+    removedRefs.value = [];
+    skillModalOpen.value = false;
+    skillRefInput.value = "";
+    skillError.value = "";
+    discoveringSkills.value = false;
+  }
+  return {
+    displayedSkills,
+    filteredSkills,
+    hasChanges,
+    isPending,
+    addSkill,
+    removeSkill,
+    buildExternalSkills,
+    initialize,
+    skillModalOpen,
+    skillRefInput,
+    skillError,
+    discoveringSkills,
+    handleAddSkill,
+    closeSkillModal,
+    handleAddSkillAndClose,
+    getGitHubButtonText,
+    skillsConnection,
+    fetchGitHubConnection,
+    connectGitHub
+  };
+}

package/dist/runtime/composables/useWorkspaceKnowledgeSources.d.ts

@@ -0,0 +1,11 @@
+import type { KnowledgeSource } from '../types/chat.js';
+import type { TelaCanvas, TelaProject, TelaWorkstation } from '../types/tela.js';
+export declare function useWorkspaceKnowledgeSources(workstations: Ref<TelaWorkstation[]> | ComputedRef<TelaWorkstation[]>, canvas: Ref<TelaCanvas[]> | ComputedRef<TelaCanvas[]>, projects: Ref<TelaProject[]> | ComputedRef<TelaProject[]>, searchQuery: Ref<string>, currentKnowledgeSources: Ref<readonly KnowledgeSource[] | null | undefined> | ComputedRef<readonly KnowledgeSource[] | null | undefined>): {
+    selectedKnowledgeSourceIds: any;
+    filteredWorkstations: any;
+    hasChanges: any;
+    toggleKnowledgeSource: (sourceId: string) => void;
+    getProjectNameForWorkstation: (workstation: TelaWorkstation) => string;
+    buildKnowledgeSources: () => KnowledgeSource[];
+    initialize: () => void;
+};

package/dist/runtime/composables/useWorkspaceKnowledgeSources.js

@@ -0,0 +1,88 @@
+export function useWorkspaceKnowledgeSources(workstations, canvas, projects, searchQuery, currentKnowledgeSources) {
+  const selectedKnowledgeSourceIds = ref(/* @__PURE__ */ new Set());
+  function getProjectIdForWorkstation(workstation) {
+    const prompt = canvas.value.find((c) => c.id === workstation.promptId);
+    return prompt?.projectId;
+  }
+  function getProjectNameForWorkstation(workstation) {
+    const projectId = getProjectIdForWorkstation(workstation);
+    if (!projectId)
+      return "Sem projeto";
+    const project = projects.value.find((p) => p.id === projectId);
+    return project?.title ?? "Sem projeto";
+  }
+  function sortWithSelectedFirst(list) {
+    return [...list].sort((a, b) => {
+      const aSelected = selectedKnowledgeSourceIds.value.has(a.id);
+      const bSelected = selectedKnowledgeSourceIds.value.has(b.id);
+      if (aSelected && !bSelected)
+        return -1;
+      if (!aSelected && bSelected)
+        return 1;
+      return a.name.localeCompare(b.name);
+    });
+  }
+  const filteredWorkstations = computed(() => {
+    if (!searchQuery.value.trim())
+      return sortWithSelectedFirst(workstations.value);
+    const query = searchQuery.value.toLowerCase();
+    const matchingProjectIds = new Set(
+      projects.value.filter((p) => p.title.toLowerCase().includes(query)).map((p) => p.id)
+    );
+    const filtered = workstations.value.filter((w) => {
+      const projectId = getProjectIdForWorkstation(w);
+      return w.name.toLowerCase().includes(query) || w.description?.toLowerCase().includes(query) || projectId && matchingProjectIds.has(projectId);
+    });
+    return sortWithSelectedFirst(filtered);
+  });
+  const hasChanges = computed(() => {
+    const currentIds = new Set(currentKnowledgeSources.value?.map((s) => s.id) ?? []);
+    if (currentIds.size !== selectedKnowledgeSourceIds.value.size)
+      return true;
+    for (const id of currentIds) {
+      if (!selectedKnowledgeSourceIds.value.has(id))
+        return true;
+    }
+    return false;
+  });
+  function toggleKnowledgeSource(sourceId) {
+    const newSet = new Set(selectedKnowledgeSourceIds.value);
+    if (newSet.has(sourceId))
+      newSet.delete(sourceId);
+    else
+      newSet.add(sourceId);
+    selectedKnowledgeSourceIds.value = newSet;
+  }
+  function buildKnowledgeSources() {
+    const sources = [];
+    for (const sourceId of selectedKnowledgeSourceIds.value) {
+      const item = workstations.value.find((w) => w.id === sourceId);
+      if (!item)
+        continue;
+      const projectId = getProjectIdForWorkstation(item);
+      if (!projectId)
+        continue;
+      sources.push({
+        type: "workstation",
+        id: sourceId,
+        name: item.name,
+        projectId,
+        description: item.description,
+        taskCount: item.taskCount
+      });
+    }
+    return sources;
+  }
+  function initialize() {
+    selectedKnowledgeSourceIds.value = new Set(currentKnowledgeSources.value?.map((s) => s.id) ?? []);
+  }
+  return {
+    selectedKnowledgeSourceIds,
+    filteredWorkstations,
+    hasChanges,
+    toggleKnowledgeSource,
+    getProjectNameForWorkstation,
+    buildKnowledgeSources,
+    initialize
+  };
+}

package/dist/runtime/composables/useWorkspaceMembers.d.ts

@@ -0,0 +1,13 @@
+type MemberUser = {
+    name: string;
+    email: string;
+    image?: string;
+};
+export declare function useWorkspaceMembers(): {
+    members: any;
+    membersMap: any;
+    getMemberImage: (userId: string) => string | undefined;
+    getMember: (userId: string) => MemberUser | undefined;
+    getMemberByEmail: (email: string) => MemberUser | undefined;
+};
+export {};

package/dist/runtime/composables/useWorkspaceMembers.js

@@ -0,0 +1,37 @@
+export function useWorkspaceMembers() {
+  const { activeOrganization } = useTelaApplicationAuth();
+  const members = computed(() => activeOrganization.value?.members ?? []);
+  const membersMap = computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const member of members.value) {
+      map.set(member.userId, member.user);
+    }
+    return map;
+  });
+  const membersEmailMap = computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const member of members.value) {
+      const email = member.user.email?.toLowerCase();
+      if (email) {
+        map.set(email, member.user);
+      }
+    }
+    return map;
+  });
+  function getMemberImage(userId) {
+    return membersMap.value.get(userId)?.image ?? void 0;
+  }
+  function getMember(userId) {
+    return membersMap.value.get(userId);
+  }
+  function getMemberByEmail(email) {
+    return membersEmailMap.value.get(email.toLowerCase());
+  }
+  return {
+    members,
+    membersMap,
+    getMemberImage,
+    getMember,
+    getMemberByEmail
+  };
+}

package/dist/runtime/composables/useWorkspacePersonalization.d.ts

@@ -0,0 +1,6 @@
+export declare function useWorkspacePersonalization(): {
+    localSystemMessage: any;
+    hasChanges: any;
+    getSystemMessage: () => string | null;
+    initialize: () => void;
+};

package/dist/runtime/composables/useWorkspacePersonalization.js

@@ -0,0 +1,19 @@
+export function useWorkspacePersonalization() {
+  const { settings } = useWorkspaceSettings();
+  const localSystemMessage = useState("workspace-personalization-system-message", () => "");
+  const hasChanges = computed(
+    () => localSystemMessage.value !== (settings.value?.systemMessage ?? "")
+  );
+  function getSystemMessage() {
+    return localSystemMessage.value.trim() || null;
+  }
+  function initialize() {
+    localSystemMessage.value = settings.value?.systemMessage ?? "";
+  }
+  return {
+    localSystemMessage,
+    hasChanges,
+    getSystemMessage,
+    initialize
+  };
+}

package/dist/runtime/composables/useWorkspaceSettings.d.ts

@@ -0,0 +1,30 @@
+import type { ContextFile, ExternalSkill } from '../server/db/schema.js';
+import type { CanvasTool } from '../types/agent.js';
+import type { KnowledgeSource } from '../types/chat.js';
+export type WorkspaceSettings = {
+    workspaceId: string;
+    systemMessage: string | null;
+    contextFiles: ContextFile[] | null;
+    canvasTools: CanvasTool[] | null;
+    knowledgeSources: KnowledgeSource[] | null;
+    externalSkills: ExternalSkill[] | null;
+    updatedAt: Date;
+};
+export type WorkspaceSettingsUpdate = {
+    systemMessage?: string | null;
+    contextFiles?: ContextFile[] | null;
+    canvasTools?: CanvasTool[] | null;
+    knowledgeSources?: KnowledgeSource[] | null;
+    externalSkills?: ExternalSkill[] | null;
+};
+export declare function useWorkspaceSettings(): {
+    settings: any;
+    loading: any;
+    error: any;
+    fetchSettings: () => Promise<WorkspaceSettings>;
+    updateSettings: (updates: WorkspaceSettingsUpdate) => Promise<WorkspaceSettings>;
+    isModalOpen: any;
+    initialTab: any;
+    openModal: (tab?: string) => void;
+    closeModal: () => void;
+};

package/dist/runtime/composables/useWorkspaceSettings.js

@@ -0,0 +1,135 @@
+import * as Sentry from "@sentry/nuxt";
+export function useWorkspaceSettings() {
+  const chatApi = useChatApi();
+  const embedConfig = useEmbedConfig();
+  const workspaceScope = computed(() => embedConfig?.workspaceId.value.trim() || "default");
+  const settingsBuckets = useState("workspace-settings", () => ({}));
+  const loadingBuckets = useState("workspace-settings-loading", () => ({}));
+  const errorBuckets = useState("workspace-settings-error", () => ({}));
+  const settings = computed({
+    get: () => settingsBuckets.value[workspaceScope.value] ?? null,
+    set: (value) => {
+      settingsBuckets.value = {
+        ...settingsBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const loading = computed({
+    get: () => loadingBuckets.value[workspaceScope.value] ?? false,
+    set: (value) => {
+      loadingBuckets.value = {
+        ...loadingBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const error = computed({
+    get: () => errorBuckets.value[workspaceScope.value] ?? null,
+    set: (value) => {
+      errorBuckets.value = {
+        ...errorBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const isModalOpen = useState("workspace-settings-modal-open", () => false);
+  const initialTab = useState("workspace-settings-initial-tab", () => null);
+  if (embedConfig !== null && embedConfig.workspaceSettings.value !== void 0) {
+    settings.value = embedConfig.workspaceSettings.value;
+  }
+  if (embedConfig !== null) {
+    watch(() => embedConfig.workspaceSettings.value, (newSettings) => {
+      if (newSettings !== void 0) {
+        settings.value = newSettings;
+      }
+    });
+  }
+  function openModal(tab) {
+    if (embedConfig !== null)
+      return;
+    if (tab)
+      initialTab.value = tab;
+    isModalOpen.value = true;
+  }
+  function closeModal() {
+    if (embedConfig !== null)
+      return;
+    isModalOpen.value = false;
+    initialTab.value = null;
+  }
+  async function fetchSettings() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const currentSettings = settings.value;
+      let data;
+      if (embedConfig !== null) {
+        data = await $fetch(
+          chatApi.path("/workspace/settings"),
+          chatApi.withChatHeaders()
+        );
+      } else {
+        data = await $fetch("/api/workspace/settings");
+      }
+      if (import.meta.dev && embedConfig !== null && currentSettings) {
+        const hydratedSettings = {
+          systemMessage: currentSettings.systemMessage,
+          contextFiles: currentSettings.contextFiles,
+          canvasTools: currentSettings.canvasTools,
+          knowledgeSources: currentSettings.knowledgeSources,
+          externalSkills: currentSettings.externalSkills
+        };
+        const trustedSettings = {
+          systemMessage: data.systemMessage,
+          contextFiles: data.contextFiles,
+          canvasTools: data.canvasTools,
+          knowledgeSources: data.knowledgeSources,
+          externalSkills: data.externalSkills
+        };
+        if (JSON.stringify(hydratedSettings) !== JSON.stringify(trustedSettings)) {
+          console.warn("[TelaChat] Hydrated workspace settings differ from trusted server settings");
+        }
+      }
+      settings.value = data;
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      error.value = "Falha ao carregar configura\xE7\xF5es";
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function updateSettings(updates) {
+    if (embedConfig !== null)
+      return settings.value;
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await $fetch("/api/workspace/settings", {
+        method: "PATCH",
+        body: updates
+      });
+      settings.value = data;
+      return data;
+    } catch (e) {
+      Sentry.captureException(e);
+      error.value = "Falha ao salvar configura\xE7\xF5es";
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+  return {
+    settings: readonly(settings),
+    loading: readonly(loading),
+    error: readonly(error),
+    fetchSettings,
+    updateSettings,
+    isModalOpen: readonly(isModalOpen),
+    initialTab: readonly(initialTab),
+    openModal,
+    closeModal
+  };
+}

package/dist/runtime/composables/useWorkspaceTelaTools.d.ts

@@ -0,0 +1,13 @@
+import type { CanvasTool } from '../types/agent.js';
+import type { TelaCanvas, TelaProject } from '../types/tela.js';
+export declare function useWorkspaceTelaTools(canvas: Ref<TelaCanvas[]> | ComputedRef<TelaCanvas[]>, projects: Ref<TelaProject[]> | ComputedRef<TelaProject[]>, searchQuery: Ref<string>, currentCanvasTools: Ref<readonly CanvasTool[] | null | undefined> | ComputedRef<readonly CanvasTool[] | null | undefined>): {
+    selectedToolIds: any;
+    filteredCanvasTools: any;
+    allToolsSelected: any;
+    hasChanges: any;
+    toggleCanvasTool: (canvasId: string) => void;
+    toggleAllTools: (selected: boolean | "indeterminate") => void;
+    getProjectName: (projectId: string) => string;
+    buildCanvasTools: () => CanvasTool[];
+    initialize: () => void;
+};