@meistrari/chat-nuxt 1.13.0 → 2.0.0

package/dist/runtime/files/content-detection.js

@@ -0,0 +1,258 @@
+import { getExtensionFromUrl, getMimeTypeFromExtension, isFileUrl } from "./mime.js";
+import {
+  getPermalinkId,
+  isVaultPermalink,
+  isVaultS3Url,
+  normalizeVaultPermalinkUrl,
+  parseVaultHashParams,
+  stripTrailingPunctuation,
+  URL_REGEX,
+  VAULT_REGEX
+} from "./vault-links.js";
+const MARKDOWN_LINK_PATTERN = /\[([^\]\n]*)\]\(([^)\s]+)(?:\s+["'][^)]*["'])?\)/g;
+function getNameFromUrl(url) {
+  const cleanUrl = url.split("?")[0]?.split("#")[0];
+  if (!cleanUrl)
+    return url;
+  const parts = cleanUrl.split("/");
+  return parts[parts.length - 1] ?? url;
+}
+function getNameFromVaultReference(reference) {
+  const parts = reference.replace("vault://", "").split("/");
+  return parts[parts.length - 1] || "Arquivo";
+}
+function getFileInfoFromVaultS3Url(url) {
+  const filenameMatch = url.match(/filename%3D%22([^%]+)%22/);
+  if (filenameMatch?.[1]) {
+    const name = decodeURIComponent(filenameMatch[1]);
+    const ext = name.split(".").pop()?.toLowerCase();
+    return {
+      name,
+      mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown"
+    };
+  }
+  return { name: "Arquivo", mimeType: "unknown" };
+}
+function overlapsFileMatch(start, end, fileMatches) {
+  return fileMatches.some((fileMatch) => start < fileMatch.end && end > fileMatch.start);
+}
+function collectMarkdownFileLinkMatches(text) {
+  const matches = [];
+  for (const match of text.matchAll(MARKDOWN_LINK_PATTERN)) {
+    const start = match.index;
+    if (text[start - 1] === "!")
+      continue;
+    const href = match[2];
+    if (!href)
+      continue;
+    const file = detectFileFromUrl(href);
+    if (!file)
+      continue;
+    matches.push({
+      start,
+      end: start + match[0].length,
+      file
+    });
+  }
+  return matches;
+}
+export function detectFilesInText(text) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const markdownFileLinkMatches = collectMarkdownFileLinkMatches(text);
+  for (const { file } of markdownFileLinkMatches) {
+    if (seen.has(file.reference))
+      continue;
+    seen.add(file.reference);
+    files.push(file);
+  }
+  for (const rawMatch of text.matchAll(VAULT_REGEX)) {
+    const match = stripTrailingPunctuation(rawMatch[0]);
+    const start = rawMatch.index;
+    if (overlapsFileMatch(start, start + match.length, markdownFileLinkMatches))
+      continue;
+    if (seen.has(match))
+      continue;
+    seen.add(match);
+    const hashParams = parseVaultHashParams(match);
+    const filenameExt = hashParams?.filename?.split(".").pop()?.toLowerCase();
+    const urlExt = getExtensionFromUrl(match);
+    const ext = filenameExt ?? urlExt;
+    files.push({
+      type: "vault",
+      reference: match,
+      name: hashParams?.filename ?? getNameFromVaultReference(match),
+      mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown",
+      hashParams
+    });
+  }
+  for (const rawMatch of text.matchAll(URL_REGEX)) {
+    const match = stripTrailingPunctuation(rawMatch[0]);
+    const start = rawMatch.index;
+    if (overlapsFileMatch(start, start + match.length, markdownFileLinkMatches))
+      continue;
+    if (seen.has(match))
+      continue;
+    if (isVaultS3Url(match)) {
+      seen.add(match);
+      const { name, mimeType } = getFileInfoFromVaultS3Url(match);
+      files.push({
+        type: "url",
+        reference: match,
+        name,
+        mimeType
+      });
+      continue;
+    }
+    if (isVaultPermalink(match)) {
+      const normalized = normalizeVaultPermalinkUrl(match);
+      seen.add(match);
+      files.push({
+        type: "url",
+        reference: normalized,
+        name: "Arquivo",
+        mimeType: "unknown"
+      });
+      continue;
+    }
+    if (!isFileUrl(match))
+      continue;
+    seen.add(match);
+    const ext = getExtensionFromUrl(match);
+    files.push({
+      type: "url",
+      reference: match,
+      name: getNameFromUrl(match),
+      mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown"
+    });
+  }
+  return files;
+}
+export function parseContentWithFiles(text) {
+  const segments = [];
+  const fileMatches = collectMarkdownFileLinkMatches(text);
+  for (const match of text.matchAll(VAULT_REGEX)) {
+    const rawUrl = match[0];
+    const url = stripTrailingPunctuation(rawUrl);
+    if (overlapsFileMatch(match.index, match.index + url.length, fileMatches))
+      continue;
+    const hashParams = parseVaultHashParams(url);
+    const filenameExt = hashParams?.filename?.split(".").pop()?.toLowerCase();
+    const urlExt = getExtensionFromUrl(url);
+    const ext = filenameExt ?? urlExt;
+    fileMatches.push({
+      start: match.index,
+      end: match.index + url.length,
+      file: {
+        type: "vault",
+        reference: url,
+        name: hashParams?.filename ?? getNameFromVaultReference(url),
+        mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown",
+        hashParams
+      }
+    });
+  }
+  for (const match of text.matchAll(URL_REGEX)) {
+    const rawUrl = match[0];
+    const url = stripTrailingPunctuation(rawUrl);
+    if (overlapsFileMatch(match.index, match.index + url.length, fileMatches))
+      continue;
+    if (isVaultS3Url(url)) {
+      const { name, mimeType } = getFileInfoFromVaultS3Url(url);
+      fileMatches.push({
+        start: match.index,
+        end: match.index + url.length,
+        file: {
+          type: "url",
+          reference: url,
+          name,
+          mimeType
+        }
+      });
+      continue;
+    }
+    if (isVaultPermalink(url)) {
+      fileMatches.push({
+        start: match.index,
+        end: match.index + url.length,
+        file: {
+          type: "url",
+          reference: normalizeVaultPermalinkUrl(url),
+          name: "Arquivo",
+          mimeType: "unknown"
+        }
+      });
+      continue;
+    }
+    if (isFileUrl(url)) {
+      const ext = getExtensionFromUrl(url);
+      fileMatches.push({
+        start: match.index,
+        end: match.index + url.length,
+        file: {
+          type: "url",
+          reference: url,
+          name: getNameFromUrl(url),
+          mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown"
+        }
+      });
+    }
+  }
+  if (fileMatches.length === 0)
+    return [{ type: "text", content: text }];
+  fileMatches.sort((a, b) => a.start - b.start);
+  let lastEnd = 0;
+  for (const fm of fileMatches) {
+    if (fm.start > lastEnd) {
+      const textContent = text.slice(lastEnd, fm.start);
+      if (textContent)
+        segments.push({ type: "text", content: textContent });
+    }
+    segments.push({ type: "file", file: fm.file });
+    lastEnd = fm.end;
+  }
+  if (lastEnd < text.length) {
+    const textContent = text.slice(lastEnd);
+    if (textContent)
+      segments.push({ type: "text", content: textContent });
+  }
+  return segments;
+}
+export function detectFileFromUrl(url) {
+  if (url.toLowerCase().startsWith("vault://")) {
+    const cleaned = stripTrailingPunctuation(url);
+    const hashParams = parseVaultHashParams(cleaned);
+    const filenameExt = hashParams?.filename?.split(".").pop()?.toLowerCase();
+    const urlExt = getExtensionFromUrl(cleaned);
+    const ext = filenameExt ?? urlExt;
+    return {
+      type: "vault",
+      reference: cleaned,
+      name: hashParams?.filename ?? getNameFromVaultReference(cleaned),
+      mimeType: ext ? getMimeTypeFromExtension(ext) : "unknown",
+      hashParams
+    };
+  }
+  if (isVaultPermalink(url)) {
+    const cleaned = normalizeVaultPermalinkUrl(stripTrailingPunctuation(url));
+    const hashParams = parseVaultHashParams(cleaned);
+    return {
+      type: "url",
+      reference: cleaned,
+      name: hashParams?.filename ?? getPermalinkId(cleaned),
+      mimeType: "unknown",
+      hashParams
+    };
+  }
+  if (isVaultS3Url(url)) {
+    const cleaned = stripTrailingPunctuation(url);
+    const { name, mimeType } = getFileInfoFromVaultS3Url(cleaned);
+    return {
+      type: "url",
+      reference: cleaned,
+      name,
+      mimeType
+    };
+  }
+  return null;
+}

package/dist/runtime/files/formatting.d.ts

@@ -0,0 +1,3 @@
+export declare function getFileTypeLabel(mimeType: string): string;
+export declare function formatUploadDate(date?: Date): string;
+export declare function formatFileSize(bytes?: number): string;

package/dist/runtime/files/formatting.js

@@ -0,0 +1,48 @@
+export function getFileTypeLabel(mimeType) {
+  if (mimeType.includes("pdf"))
+    return "PDF";
+  if (mimeType.includes("word") || mimeType.includes("document"))
+    return "DOC";
+  if (mimeType.includes("excel") || mimeType.includes("spreadsheet") || mimeType.includes("csv"))
+    return "Planilha";
+  if (mimeType.includes("powerpoint") || mimeType.includes("presentation"))
+    return "Apresenta\xE7\xE3o";
+  if (mimeType.startsWith("image/"))
+    return "Imagem";
+  if (mimeType.startsWith("video/"))
+    return "V\xEDdeo";
+  if (mimeType.startsWith("audio/"))
+    return "\xC1udio";
+  if (mimeType.includes("json"))
+    return "JSON";
+  if (mimeType.includes("text"))
+    return "Texto";
+  return "Arquivo";
+}
+export function formatUploadDate(date) {
+  if (!date)
+    return "-";
+  const now = /* @__PURE__ */ new Date();
+  const d = new Date(date);
+  const isToday = d.toDateString() === now.toDateString();
+  if (isToday) {
+    return `Hoje \xE0s ${d.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" })}`;
+  }
+  const yesterday = new Date(now);
+  yesterday.setDate(yesterday.getDate() - 1);
+  if (d.toDateString() === yesterday.toDateString()) {
+    return `Ontem \xE0s ${d.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" })}`;
+  }
+  return d.toLocaleDateString("pt-BR", { day: "2-digit", month: "short", year: "numeric" });
+}
+export function formatFileSize(bytes) {
+  if (bytes == null)
+    return "-";
+  if (bytes === 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const base = 1024;
+  const unitIndex = Math.min(Math.floor(Math.log(bytes) / Math.log(base)), units.length - 1);
+  const value = bytes / base ** unitIndex;
+  return `${value.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}

package/dist/runtime/files/icons.d.ts

@@ -0,0 +1,4 @@
+export declare const FILE_ICONS: Record<string, string>;
+export declare function getFileIcon(mimeType: string): string;
+export declare function getMimeIcon(mimeType?: string): string;
+export declare function getMimeLabel(mimeType?: string): string;

package/dist/runtime/files/icons.js

@@ -0,0 +1,76 @@
+export const FILE_ICONS = {
+  "application/pdf": "/chat-files/pdf.svg",
+  "application/msword": "/chat-files/doc.svg",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "/chat-files/doc.svg",
+  "application/vnd.ms-excel": "/chat-files/sheet.svg",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "/chat-files/sheet.svg",
+  "application/vnd.ms-powerpoint": "/chat-files/presentation.svg",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "/chat-files/presentation.svg",
+  "text/csv": "/chat-files/sheet.svg",
+  "text/plain": "/chat-files/generic.svg",
+  "text/markdown": "/chat-files/markdown.svg",
+  "application/json": "/chat-files/json.svg",
+  "application/xml": "/chat-files/generic.svg",
+  "application/zip": "/chat-files/archive.svg",
+  "application/x-rar-compressed": "/chat-files/archive.svg",
+  "application/x-tar": "/chat-files/archive.svg",
+  "application/gzip": "/chat-files/archive.svg",
+  "image/jpeg": "/chat-files/image.svg",
+  "image/png": "/chat-files/image.svg",
+  "image/gif": "/chat-files/image.svg",
+  "image/webp": "/chat-files/image.svg",
+  "image/svg+xml": "/chat-files/image.svg",
+  "video/mp4": "/chat-files/video.svg",
+  "video/webm": "/chat-files/video.svg",
+  "audio/mpeg": "/chat-files/audio.svg",
+  "audio/wav": "/chat-files/audio.svg",
+  "audio/ogg": "/chat-files/audio.svg",
+  "text/x-python": "/chat-files/python.svg",
+  "text/javascript": "/chat-files/javascript.svg",
+  "text/typescript": "/chat-files/typescript.svg",
+  "text/html": "/chat-files/html.svg",
+  "text/css": "/chat-files/css.svg",
+  "text/sql": "/chat-files/sql.svg",
+  "text/yaml": "/chat-files/yaml.svg",
+  "text/x-go": "/chat-files/go.svg",
+  "text/x-rust": "/chat-files/rust.svg",
+  "text/x-ruby": "/chat-files/ruby.svg",
+  "text/x-java": "/chat-files/java.svg",
+  "text/x-shellscript": "/chat-files/shell.svg",
+  "text/x-c": "/chat-files/c.svg",
+  "text/x-cpp": "/chat-files/cpp.svg",
+  "unknown": "/chat-files/generic.svg"
+};
+export function getFileIcon(mimeType) {
+  return FILE_ICONS[mimeType] ?? "/chat-files/generic.svg";
+}
+export function getMimeIcon(mimeType) {
+  if (!mimeType)
+    return "i-ph-file";
+  if (mimeType.includes("pdf"))
+    return "i-ph-file-pdf";
+  if (mimeType.startsWith("image/"))
+    return "i-ph-file-image";
+  if (mimeType.includes("spreadsheet") || mimeType.includes("excel"))
+    return "i-ph-file-xls";
+  if (mimeType.includes("document") || mimeType.includes("word"))
+    return "i-ph-file-doc";
+  if (mimeType.startsWith("text/"))
+    return "i-ph-file-text";
+  return "i-ph-file";
+}
+export function getMimeLabel(mimeType) {
+  if (!mimeType)
+    return "Arquivo";
+  if (mimeType.includes("pdf"))
+    return "PDF";
+  if (mimeType.startsWith("image/"))
+    return "Imagem";
+  if (mimeType.includes("spreadsheet") || mimeType.includes("excel"))
+    return "Planilha";
+  if (mimeType.includes("document") || mimeType.includes("word"))
+    return "Documento";
+  if (mimeType.startsWith("text/"))
+    return "Texto";
+  return "Arquivo";
+}

package/dist/runtime/files/mime.d.ts

@@ -0,0 +1,6 @@
+export declare const FILE_EXTENSIONS: Record<string, string>;
+export declare const MIME_TO_EXTENSION: Record<string, string>;
+export declare function normalizeMimeType(mimeType: string): string;
+export declare function getExtensionFromUrl(url: string): string | undefined;
+export declare function getMimeTypeFromExtension(ext: string): string;
+export declare function isFileUrl(url: string): boolean;

package/dist/runtime/files/mime.js

@@ -0,0 +1,78 @@
+export const FILE_EXTENSIONS = {
+  pdf: "application/pdf",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  csv: "text/csv",
+  txt: "text/plain",
+  md: "text/markdown",
+  json: "application/json",
+  xml: "application/xml",
+  zip: "application/zip",
+  rar: "application/x-rar-compressed",
+  tar: "application/x-tar",
+  gz: "application/gzip",
+  tgz: "application/gzip",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  py: "text/x-python",
+  js: "text/javascript",
+  ts: "text/typescript",
+  jsx: "text/javascript",
+  tsx: "text/typescript",
+  html: "text/html",
+  css: "text/css",
+  sql: "text/sql",
+  yaml: "text/yaml",
+  yml: "text/yaml",
+  go: "text/x-go",
+  rs: "text/x-rust",
+  rb: "text/x-ruby",
+  java: "text/x-java",
+  sh: "text/x-shellscript",
+  bash: "text/x-shellscript",
+  zsh: "text/x-shellscript",
+  c: "text/x-c",
+  h: "text/x-c",
+  cpp: "text/x-cpp",
+  cc: "text/x-cpp",
+  cxx: "text/x-cpp",
+  hpp: "text/x-cpp"
+};
+export const MIME_TO_EXTENSION = (() => {
+  const map = {};
+  for (const [ext, mime] of Object.entries(FILE_EXTENSIONS)) {
+    if (!(mime in map))
+      map[mime] = ext;
+  }
+  return map;
+})();
+export function normalizeMimeType(mimeType) {
+  return mimeType.split(";")[0]?.trim() ?? mimeType;
+}
+export function getExtensionFromUrl(url) {
+  const cleanUrl = url.split("?")[0]?.split("#")[0];
+  if (!cleanUrl)
+    return void 0;
+  const match = cleanUrl.match(/\.([a-zA-Z0-9]+)$/);
+  return match?.[1]?.toLowerCase();
+}
+export function getMimeTypeFromExtension(ext) {
+  return FILE_EXTENSIONS[ext] ?? "unknown";
+}
+export function isFileUrl(url) {
+  const ext = getExtensionFromUrl(url);
+  return ext !== void 0 && ext in FILE_EXTENSIONS;
+}

package/dist/runtime/files/references.d.ts

@@ -0,0 +1,8 @@
+export declare function generateFileId(url: string): string;
+export declare function mergeFileUrls(contextFiles: {
+    vaultReference?: string | null;
+    url: string;
+}[] | null | undefined, messageFiles: {
+    vaultReference?: string | null;
+    url: string;
+}[] | null | undefined): string[] | undefined;

package/dist/runtime/files/references.js

@@ -0,0 +1,15 @@
+export function generateFileId(url) {
+  let hash = 0;
+  for (let i = 0; i < url.length; i++) {
+    const char = url.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+export function mergeFileUrls(contextFiles, messageFiles) {
+  const contextFileUrls = contextFiles?.map((f) => f.vaultReference || f.url) ?? [];
+  const messageFileUrls = messageFiles?.map((f) => f.vaultReference || f.url) ?? [];
+  const allFileUrls = [...contextFileUrls, ...messageFileUrls];
+  return allFileUrls.length > 0 ? allFileUrls : void 0;
+}

package/dist/runtime/files/vault-links.d.ts

@@ -0,0 +1,14 @@
+export type VaultHashParams = {
+    filename?: string;
+    pageNumber?: number;
+};
+export declare const VAULT_REGEX: RegExp;
+export declare const URL_REGEX: RegExp;
+export declare const VAULT_PATTERN: RegExp;
+export declare const VAULT_PERMALINK_PATTERN: RegExp;
+export declare function stripTrailingPunctuation(url: string): string;
+export declare function isVaultS3Url(url: string): boolean;
+export declare function normalizeVaultPermalinkUrl(url: string): string;
+export declare function isVaultPermalink(url: string): boolean;
+export declare function parseVaultHashParams(url: string): VaultHashParams | undefined;
+export declare function getPermalinkId(url: string): string;

package/dist/runtime/files/vault-links.js

@@ -0,0 +1,55 @@
+const URL_CHAR_CLASS = "[^\\s\"'<>`\\[\\]()*_~]+";
+export const VAULT_REGEX = /(?<!\]\()vault:\/\/[^\s"'<>`\[\]()*_~]+/gi;
+export const URL_REGEX = /https?:\/\/[^\s"'<>`\[\]()*_~]+/gi;
+export const VAULT_PATTERN = new RegExp(`vault://${URL_CHAR_CLASS}`, "gi");
+export const VAULT_PERMALINK_PATTERN = new RegExp(`https://(?:[a-z0-9-]+\\.)*(?:vault|api)\\.tela(?:staging)?\\.com/(?:[a-z0-9_-]+/)*permalinks/${URL_CHAR_CLASS}`, "gi");
+export function stripTrailingPunctuation(url) {
+  return url.replace(/[.,:;!?]+$/, "");
+}
+function sanitizeFilename(filename) {
+  return filename.replace(/\.\./g, "").replace(/[/\\]/g, "-").replace(/^\.+/, "").replace(/[\x00-\x1F<>:"|?*]/g, "").replace(/^-+/, "").replace(/-+/g, "-").trim();
+}
+export function isVaultS3Url(url) {
+  return url.includes("vault-staging-permanentstorage.s3") || url.includes("vault-prod-permanentstorage.s3");
+}
+export function normalizeVaultPermalinkUrl(url) {
+  return url.replace(
+    /^(https:\/\/(?:[a-z0-9-]+\.)*api\.tela(?:staging)?\.com)\/(permalinks\/)/,
+    "$1/_services/vault/$2"
+  );
+}
+export function isVaultPermalink(url) {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.host;
+    const isTelaHost = host === "vault.tela.com" || host.endsWith(".vault.tela.com") || host === "api.tela.com" || host.endsWith(".api.tela.com") || host === "api.telastaging.com" || host.endsWith(".api.telastaging.com");
+    return isTelaHost && /(?:^|\/)permalinks\//.test(parsed.pathname);
+  } catch {
+    return /^https:\/\/(?:[a-z0-9-]+\.)*(?:vault|api)\.tela(?:staging)?\.com\/(?:[a-z0-9_-]+\/)*permalinks\//.test(url);
+  }
+}
+export function parseVaultHashParams(url) {
+  const hashIndex = url.indexOf("#");
+  if (hashIndex === -1)
+    return void 0;
+  const hashPart = url.slice(hashIndex + 1);
+  const params = new URLSearchParams(hashPart);
+  const result = {};
+  const filename = params.get("filename");
+  if (filename) {
+    const sanitized = sanitizeFilename(filename);
+    if (sanitized)
+      result.filename = sanitized;
+  }
+  const pageNumber = params.get("page_number");
+  if (pageNumber) {
+    const parsed = Number.parseInt(pageNumber, 10);
+    if (!Number.isNaN(parsed) && parsed > 0)
+      result.pageNumber = parsed;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+export function getPermalinkId(url) {
+  const match = url.match(/permalinks\/([a-f0-9-]+)/);
+  return match?.[1] ?? "Arquivo";
+}

package/dist/runtime/messages/components/chat-canvas-selector-modal.d.vue.ts

@@ -0,0 +1,14 @@
+import type { CanvasTool } from '../../types/schemas/tools/canvas.js';
+type __VLS_Props = {
+    open: boolean;
+    canvasTools: readonly CanvasTool[] | CanvasTool[] | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+    save: (tools: CanvasTool[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onSave?: ((tools: CanvasTool[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;