@meistrari/chat-nuxt 1.0.0

package/dist/runtime/server/api/conversations/[id]/messages/index.post.js

@@ -0,0 +1,181 @@
+import { eq, and, isNull } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { buildMessageWithContext, renderSystemPrompt, truncateTitle } from "#chat-runtime/server/utils/chat-message-builder";
+import { getAgentDataToken, createChatAgentSession, continueSession } from "#chat-runtime/server/utils/agent-api";
+import { logger } from "#chat-runtime/server/utils/logger";
+import {
+  getConversationAppliedSettings,
+  getWorkspaceSettingsUpdatedAt,
+  resolveWorkspaceSettings,
+  serializeResolvedWorkspaceSettings
+} from "#chat-runtime/server/utils/chat-workspace-settings";
+import { resolveWorkspaceCredentials } from "#chat-runtime/server/utils/workspace";
+import { mergeFileUrls } from "#chat-runtime/utils/file";
+import { isValidModel } from "#chat-runtime/types/chat";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatContext(event);
+  const token = getAgentDataToken(event);
+  const db = useDb();
+  const conversationId = getRouterParam(event, "id");
+  const body = await readBody(event);
+  if (!conversationId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Conversation ID is required"
+    });
+  }
+  if (!body.content?.trim()) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Message content is required"
+    });
+  }
+  if (body.model !== void 0 && !isValidModel(body.model)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid model"
+    });
+  }
+  const [conversation] = await db.select().from(schema.conversations).where(
+    and(
+      eq(schema.conversations.id, conversationId),
+      eq(schema.conversations.workspaceId, context.workspaceId)
+    )
+  );
+  if (!conversation) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  const effectiveModel = body.model ?? (isValidModel(conversation.model) ? conversation.model : void 0);
+  const trustedSettings = conversation.appliedSettingsSnapshot ? null : await resolveWorkspaceSettings(event, context, db);
+  const appliedSettings = getConversationAppliedSettings(conversation, trustedSettings);
+  const now = /* @__PURE__ */ new Date();
+  const assistantCreatedAt = new Date(now.getTime() + 1);
+  if (!conversation.appliedSettingsSnapshot && trustedSettings) {
+    await db.update(schema.conversations).set({
+      appliedSettingsAt: getWorkspaceSettingsUpdatedAt(trustedSettings),
+      appliedSettingsSnapshot: serializeResolvedWorkspaceSettings(trustedSettings),
+      updatedAt: now
+    }).where(and(
+      eq(schema.conversations.id, conversationId),
+      isNull(schema.conversations.appliedSettingsSnapshot)
+    ));
+  }
+  const [userMessages, assistantMessages] = await Promise.all([
+    db.insert(schema.messages).values({
+      conversationId,
+      role: "user",
+      content: body.content.trim(),
+      status: "completed",
+      files: body.files?.map((f) => ({ ...f, source: "user" })),
+      createdBy: context.user.email,
+      createdAt: now
+    }).returning(),
+    db.insert(schema.messages).values({
+      conversationId,
+      role: "assistant",
+      content: "",
+      status: "pending",
+      createdAt: assistantCreatedAt
+    }).returning()
+  ]);
+  const userMessage = userMessages[0];
+  const assistantMessage = assistantMessages[0];
+  if (!userMessage || !assistantMessage) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to create messages"
+    });
+  }
+  logger.info({ conversationId, userMessageId: userMessage.id, hasFiles: !!body.files?.length }, "Message sent");
+  const assistantMessageId = assistantMessage.id;
+  const needsNewThread = conversation.threadSessionId === null;
+  const fileUrls = mergeFileUrls(appliedSettings.contextFiles, body.files);
+  const messageTitle = truncateTitle(body.content);
+  const knowledgeSources = appliedSettings.knowledgeSources ?? null;
+  const { vaultUrl } = useRuntimeConfig();
+  const messageWithContext = buildMessageWithContext(
+    body.content.trim(),
+    appliedSettings.systemMessage ?? null,
+    knowledgeSources,
+    needsNewThread,
+    needsNewThread ? renderSystemPrompt(vaultUrl) : ""
+  );
+  const canvasTools = appliedSettings.canvasTools;
+  const hasKnowledgeSources = knowledgeSources && knowledgeSources.length > 0;
+  const externalSkillRefs = appliedSettings.externalSkills?.map((skill) => skill.ref) ?? [];
+  const settingsTimestamp = getWorkspaceSettingsUpdatedAt(appliedSettings);
+  const skills = externalSkillRefs.length > 0 ? externalSkillRefs : void 0;
+  if (needsNewThread) {
+    let environmentVariables = {};
+    try {
+      environmentVariables = await resolveWorkspaceCredentials(event, context.workspaceId);
+    } catch (error) {
+      logger.warn({ conversationId, error }, "Failed to resolve workspace credentials, proceeding without env vars");
+    }
+    const hasEnvironmentVariables = Object.keys(environmentVariables).length > 0;
+    createChatAgentSession(token, {
+      message: messageWithContext,
+      fileUrls,
+      model: effectiveModel,
+      customTools: canvasTools?.length ? { canvas: canvasTools } : void 0,
+      tools: hasKnowledgeSources ? { workstationQueryTool: true } : void 0,
+      environmentVariables: hasEnvironmentVariables ? environmentVariables : void 0,
+      skills
+    }).then(async (result) => {
+      if (result.success) {
+        logger.info({ conversationId, sessionId: result.sessionId }, "New agent thread created");
+        await db.update(schema.conversations).set({
+          threadSessionId: result.sessionId,
+          title: messageTitle,
+          appliedSettingsAt: settingsTimestamp,
+          model: effectiveModel ?? null,
+          updatedAt: /* @__PURE__ */ new Date()
+        }).where(eq(schema.conversations.id, conversationId));
+      } else {
+        logger.warn({ conversationId, error: result.error }, "Agent thread creation failed");
+        await db.update(schema.messages).set({
+          content: `Erro: ${result.error}`,
+          status: "failed"
+        }).where(eq(schema.messages.id, assistantMessageId));
+      }
+    }).catch(async (e) => {
+      logger.error({ conversationId, error: e.message }, "Agent thread creation threw exception");
+      await db.update(schema.messages).set({
+        content: "Erro: Falha ao conectar ao agente",
+        status: "failed"
+      }).where(eq(schema.messages.id, assistantMessageId));
+    });
+  } else {
+    continueSession(token, conversation.threadSessionId, {
+      content: body.content.trim(),
+      fileUrls,
+      model: effectiveModel
+    }).then(async (result) => {
+      if (!result.success) {
+        logger.warn({ conversationId, sessionId: conversation.threadSessionId, error: result.error }, "Agent session continue failed");
+        await db.update(schema.messages).set({
+          content: `Erro: ${result.error}`,
+          status: "failed"
+        }).where(eq(schema.messages.id, assistantMessageId));
+      }
+      await db.update(schema.conversations).set({
+        ...effectiveModel ? { model: effectiveModel } : {},
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(eq(schema.conversations.id, conversationId));
+    }).catch(async (e) => {
+      logger.error({ conversationId, sessionId: conversation.threadSessionId, error: e.message }, "Agent session continue threw exception");
+      await db.update(schema.messages).set({
+        content: "Erro: Falha ao continuar a sess\xE3o",
+        status: "failed"
+      }).where(eq(schema.messages.id, assistantMessageId));
+    });
+  }
+  return {
+    userMessage,
+    assistantMessage
+  };
+});

package/dist/runtime/server/api/conversations/[id]/usage.get.d.ts

@@ -0,0 +1,8 @@
+import { type BillingConfig } from '#chat-runtime/server/utils/billing';
+import type { ConversationUsage } from '#chat-runtime/utils/calculate-usage';
+export interface ConversationUsageResponse {
+    usage: ConversationUsage | null;
+    billing: BillingConfig;
+}
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/[id]/usage.get.js

@@ -0,0 +1,96 @@
+import { eq, and } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { getWorkspaceBilling, transformCostForBilling } from "#chat-runtime/server/utils/billing";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatContext(event);
+  const db = useDb();
+  const id = getRouterParam(event, "id");
+  if (!id) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Conversation ID is required"
+    });
+  }
+  const [conversation] = await db.select({ id: schema.conversations.id }).from(schema.conversations).where(
+    and(
+      eq(schema.conversations.id, id),
+      eq(schema.conversations.workspaceId, context.workspaceId)
+    )
+  );
+  if (!conversation) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  const [usage] = await db.select().from(schema.conversationUsage).where(
+    and(
+      eq(schema.conversationUsage.conversationId, id),
+      eq(schema.conversationUsage.workspaceId, context.workspaceId)
+    )
+  );
+  const billing = await getWorkspaceBilling(context.workspaceId);
+  if (!usage) {
+    return { usage: null, billing };
+  }
+  const transformedCosts = transformCostForBilling({
+    promptCost: Number(usage.promptCost),
+    completionCost: Number(usage.completionCost),
+    totalCost: Number(usage.totalCost),
+    promptTokens: usage.promptTokens,
+    completionTokens: usage.completionTokens
+  }, billing);
+  const models = [];
+  if (usage.modelUsage) {
+    const totalCostUsd = Object.values(usage.modelUsage).reduce((sum, e) => sum + (e.costUSD ?? 0), 0);
+    for (const [model, entry] of Object.entries(usage.modelUsage)) {
+      const modelCostUsd = entry.costUSD ?? 0;
+      const ratio = totalCostUsd > 0 ? modelCostUsd / totalCostUsd : 0;
+      const modelCost = transformedCosts.totalCost * ratio;
+      models.push({
+        model,
+        inputTokens: entry.inputTokens ?? 0,
+        outputTokens: entry.outputTokens ?? 0,
+        cacheReadTokens: entry.cacheReadInputTokens ?? 0,
+        cacheCreationTokens: entry.cacheCreationInputTokens ?? 0,
+        cost: modelCost,
+        contextWindow: entry.contextWindow ?? 0,
+        webSearchRequests: entry.webSearchRequests ?? 0
+      });
+    }
+  }
+  const cacheRead = usage.cacheReadInputTokens ?? 0;
+  const cacheCreation = usage.cacheCreationInputTokens ?? 0;
+  const totalInput = usage.promptTokens + cacheRead + cacheCreation;
+  const cacheHitRate = totalInput > 0 ? cacheRead / totalInput : 0;
+  const durationMs = Number(usage.durationMs) || 0;
+  const turns = usage.turns ?? 0;
+  const costPerTurn = turns > 0 ? transformedCosts.totalCost / turns : 0;
+  return {
+    usage: {
+      tokens: {
+        prompt: usage.promptTokens,
+        completion: usage.completionTokens,
+        total: usage.totalTokens,
+        cacheRead,
+        cacheCreation
+      },
+      cost: {
+        prompt: transformedCosts.promptCost,
+        completion: transformedCosts.completionCost,
+        total: transformedCosts.totalCost
+      },
+      duration: durationMs,
+      turns,
+      models,
+      metrics: {
+        cacheHitRate,
+        costPerTurn,
+        webSearchRequests: usage.webSearchRequests ?? 0,
+        webFetchRequests: usage.webFetchRequests ?? 0
+      }
+    },
+    billing
+  };
+});

package/dist/runtime/server/api/conversations/generate-title.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/generate-title.post.js

@@ -0,0 +1,49 @@
+import { createTelaClient } from "@meistrari/tela-sdk-js";
+import { logger } from "#chat-runtime/server/utils/logger";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+const TITLE_CANVAS_ID = "ba06c4a0-ef05-4fb6-b4ef-5af3d63a1ba2";
+export default defineEventHandler(async (event) => {
+  requireUser(event);
+  const { userMessage, assistantResponse } = await readBody(event);
+  if (!userMessage || !assistantResponse) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "userMessage and assistantResponse are required"
+    });
+  }
+  const { telaApiKey } = useRuntimeConfig();
+  if (!telaApiKey) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Tela API key not configured"
+    });
+  }
+  try {
+    const tela = createTelaClient({
+      apiKey: telaApiKey
+    });
+    const canvas = await tela.canvas.get({
+      id: TITLE_CANVAS_ID
+    });
+    const execution = await canvas.execute({
+      user_message: userMessage,
+      assistant_response: assistantResponse
+    });
+    const result = await execution.result;
+    const title = result?.chat_title;
+    if (!title) {
+      throw createError({
+        statusCode: 500,
+        statusMessage: "Failed to generate title"
+      });
+    }
+    logger.debug({ titleLength: title.length }, "Title generated");
+    return { title };
+  } catch (error) {
+    logger.error({ error }, "Failed to generate title");
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to generate title"
+    });
+  }
+});

package/dist/runtime/server/api/conversations/index.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/index.get.js

@@ -0,0 +1,11 @@
+import { desc, eq } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatContext(event);
+  const db = useDb();
+  const conversations = await db.select().from(schema.conversations).where(eq(schema.conversations.workspaceId, context.workspaceId)).orderBy(desc(schema.conversations.updatedAt));
+  logger.debug({ workspaceId: context.workspaceId, count: conversations.length }, "Conversations listed");
+  return conversations;
+});

package/dist/runtime/server/api/conversations/index.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/conversations/index.post.js

@@ -0,0 +1,41 @@
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatContext } from "#chat-runtime/server/utils/chat-context";
+import { logger } from "#chat-runtime/server/utils/logger";
+import { isValidModel } from "#chat-runtime/types/chat";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatContext(event);
+  const db = useDb();
+  let body = {};
+  const contentLength = getRequestHeader(event, "content-length");
+  const hasRequestBody = contentLength !== void 0 ? Number(contentLength) > 0 : Boolean(getRequestHeader(event, "transfer-encoding"));
+  if (hasRequestBody) {
+    try {
+      body = await readBody(event) ?? {};
+    } catch {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Invalid request body"
+      });
+    }
+  }
+  if (body.model !== void 0 && body.model !== null && !isValidModel(body.model)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid model"
+    });
+  }
+  const [conversation] = await db.insert(schema.conversations).values({
+    workspaceId: context.workspaceId,
+    userId: context.user.id,
+    createdBy: context.user.email,
+    ...body.model ? { model: body.model } : {}
+  }).returning();
+  if (!conversation) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to create conversation"
+    });
+  }
+  logger.info({ conversationId: conversation.id, workspaceId: context.workspaceId }, "Conversation created");
+  return conversation;
+});

package/dist/runtime/server/api/external-skills/discover.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/external-skills/discover.post.js

@@ -0,0 +1,65 @@
+import { getAgentDataToken } from "#chat-runtime/server/utils/agent-api";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  requireUser(event);
+  const body = await readBody(event);
+  const ref = typeof body?.ref === "string" ? body.ref.trim() : "";
+  const config = useRuntimeConfig();
+  if (!ref) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Skill reference is required"
+    });
+  }
+  const authToken = getAgentDataToken(event);
+  const response = await fetch(`${config.agentApiUrl}/v2/skills/discover`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": authToken
+    },
+    body: JSON.stringify({ ref })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    logger.error({
+      status: response.status,
+      ref,
+      error
+    }, "Failed to discover skill");
+    if (response.status === 404) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Skill not found. Check the reference path."
+      });
+    }
+    if (response.status === 401) {
+      const errorMessage = error.message || error.error || "Private repository - connect a provider to access";
+      logger.warn({ ref, errorMessage }, "Skill discovery returned 401");
+      throw createError({
+        statusCode: 401,
+        statusMessage: errorMessage
+      });
+    }
+    throw createError({
+      statusCode: response.status,
+      statusMessage: error.message || "Failed to discover skill"
+    });
+  }
+  const skillMetadata = await response.json();
+  if (!skillMetadata.name) {
+    throw createError({
+      statusCode: 502,
+      statusMessage: "Invalid skill metadata: missing name"
+    });
+  }
+  return {
+    ref: skillMetadata.ref,
+    name: skillMetadata.name,
+    description: skillMetadata.description,
+    runtime: skillMetadata.runtime,
+    allowedTools: skillMetadata.allowedTools,
+    isPublic: skillMetadata.isPublic ?? false
+  };
+});

package/dist/runtime/server/api/github/disconnect.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/github/disconnect.post.js

@@ -0,0 +1,21 @@
+import { getAgentDataToken } from "#chat-runtime/server/utils/agent-api";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const { workspace } = requireUser(event);
+  const config = useRuntimeConfig();
+  const token = getAgentDataToken(event);
+  const response = await fetch(`${config.agentApiUrl}/v3/connections?provider=github`, {
+    method: "DELETE",
+    headers: { Authorization: token }
+  });
+  if (!response.ok) {
+    logger.error({ status: response.status, workspaceId: workspace.id }, "Failed to disconnect GitHub");
+    throw createError({
+      statusCode: response.status,
+      statusMessage: "Failed to disconnect GitHub"
+    });
+  }
+  logger.info({ workspaceId: workspace.id }, "GitHub disconnected");
+  return { success: true };
+});

package/dist/runtime/server/api/github/status.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/github/status.get.js

@@ -0,0 +1,23 @@
+import { getAgentDataToken } from "#chat-runtime/server/utils/agent-api";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const { workspace } = requireUser(event);
+  const config = useRuntimeConfig();
+  const token = getAgentDataToken(event);
+  try {
+    const response = await fetch(`${config.agentApiUrl}/v3/connections?provider=github`, {
+      headers: { Authorization: token }
+    });
+    if (!response.ok) {
+      if (response.status === 404) {
+        return { connected: false };
+      }
+      throw new Error(`Agent API error: ${response.status}`);
+    }
+    return await response.json();
+  } catch (error) {
+    logger.warn({ error, workspaceId: workspace.id }, "Failed to get GitHub connection status");
+    return { connected: false };
+  }
+});

package/dist/runtime/server/api/tela/canvas.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/tela/canvas.get.js

@@ -0,0 +1,18 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export default defineEventHandler(async (event) => {
+  requireUser(event);
+  const query = getQuery(event);
+  const params = new URLSearchParams();
+  if (query.projectId)
+    params.set("projectId", String(query.projectId));
+  if (query.workspaceId)
+    params.set("workspaceId", String(query.workspaceId));
+  if (query.includePromotedVersion)
+    params.set("includePromotedVersion", "true");
+  const path = params.toString() ? `/prompt?${params}` : "/prompt";
+  const result = await telaFetch(event, path);
+  logger.debug({ count: result.length, projectId: query.projectId, workspaceId: query.workspaceId }, "Canvas prompts fetched");
+  return result;
+});

package/dist/runtime/server/api/tela/projects.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/tela/projects.get.js

@@ -0,0 +1,9 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export default defineEventHandler(async (event) => {
+  requireUser(event);
+  const result = await telaFetch(event, "/project");
+  logger.debug({ count: result.length }, "Projects fetched");
+  return result;
+});

package/dist/runtime/server/api/tela/workspaces.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/tela/workspaces.get.js

@@ -0,0 +1,9 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export default defineEventHandler(async (event) => {
+  requireUser(event);
+  const result = await telaFetch(event, "/workspace/stats");
+  logger.debug("Workspace stats fetched");
+  return result;
+});

package/dist/runtime/server/api/tela/workstations.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/api/tela/workstations.get.js

@@ -0,0 +1,24 @@
+import { logger } from "#chat-runtime/server/utils/logger";
+import { requireUser } from "#chat-runtime/server/utils/auth";
+import { telaFetch } from "#chat-runtime/server/utils/tela-api";
+export default defineEventHandler(async (event) => {
+  const { workspace } = requireUser(event);
+  const apps = await telaFetch(event, "/prompt-application/metrics/");
+  const workstations = await Promise.all(
+    apps.map(async ({ app, metrics }) => {
+      return {
+        id: app.id,
+        name: app.title,
+        promptId: app.promptId,
+        workspaceId: workspace.id,
+        description: app.description ?? void 0,
+        taskCount: metrics.total,
+        createdAt: app.createdAt,
+        updatedAt: app.updatedAt
+      };
+    })
+  );
+  const filtered = workstations.filter((w) => (w.taskCount ?? 0) > 0);
+  logger.debug({ total: filtered.length }, "Workstations fetched");
+  return filtered;
+});

package/dist/runtime/server/api/vault/permalink-metadata.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;