@vm0/cli 9.277.3 → 9.278.1

package/chunk-PFWBO2VK.js

@@ -0,0 +1,801 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  authHeadersSchema
+} from "./chunk-JV6LM2YC.js";
+import {
+  apiErrorSchema,
+  external_exports,
+  initContract
+} from "./chunk-GHKWW4NC.js";
+import {
+  init_esm_shims
+} from "./chunk-AUWSMG4F.js";
+
+// ../../packages/api-contracts/src/contracts/integrations.ts
+init_esm_shims();
+var c = initContract();
+var directUploadCapabilityShape = {
+  supportsUploadHeaders: external_exports.literal(true).optional()
+};
+var directUploadResponseShape = {
+  uploadHeaders: external_exports.record(external_exports.string(), external_exports.string()).optional()
+};
+var sendSlackMessageBodySchema = external_exports.object({
+  channel: external_exports.string().min(1, "Channel ID is required").optional(),
+  user: external_exports.string().min(1, "User ID is required").optional(),
+  text: external_exports.string().optional(),
+  threadTs: external_exports.string().optional(),
+  blocks: external_exports.array(external_exports.object({ type: external_exports.string() }).passthrough()).optional()
+}).refine(
+  (data) => {
+    return Boolean(data.channel) !== Boolean(data.user);
+  },
+  { message: "Exactly one of 'channel' or 'user' must be provided" }
+);
+var sendSlackMessageResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  ts: external_exports.string().optional(),
+  channel: external_exports.string().optional()
+});
+var integrationsSlackMessageContract = c.router({
+  sendMessage: {
+    method: "POST",
+    path: "/api/zero/integrations/slack/message",
+    headers: authHeadersSchema,
+    body: sendSlackMessageBodySchema,
+    responses: {
+      200: sendSlackMessageResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Send a Slack message via org bot token"
+  }
+});
+var feishuCardSchema = external_exports.record(external_exports.string(), external_exports.unknown());
+var sendFeishuMessageBodySchema = external_exports.object({
+  installationId: external_exports.string().uuid().optional(),
+  chat: external_exports.string().min(1, "Chat ID is required").optional(),
+  user: external_exports.string().min(1, "Feishu open ID is required").optional(),
+  replyToMessageId: external_exports.string().min(1, "Message ID is required").optional(),
+  replyInThread: external_exports.boolean().optional(),
+  text: external_exports.string().min(1, "Message text is required").optional(),
+  card: feishuCardSchema.optional()
+}).refine(
+  (body) => {
+    return [body.chat, body.user, body.replyToMessageId].filter(Boolean).length === 1;
+  },
+  {
+    message: "Exactly one of chat, user, or replyToMessageId is required",
+    path: ["chat"]
+  }
+).refine(
+  (body) => {
+    return Boolean(body.text) !== Boolean(body.card);
+  },
+  {
+    message: "Exactly one of text or card is required",
+    path: ["text"]
+  }
+).refine(
+  (body) => {
+    return !body.replyInThread || Boolean(body.replyToMessageId);
+  },
+  {
+    message: "replyInThread requires replyToMessageId",
+    path: ["replyInThread"]
+  }
+);
+var sendFeishuMessageResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  messageId: external_exports.string(),
+  chatId: external_exports.string().nullable()
+});
+var integrationsFeishuMessageContract = c.router({
+  sendMessage: {
+    method: "POST",
+    path: "/api/zero/integrations/feishu/message",
+    headers: authHeadersSchema,
+    body: sendFeishuMessageBodySchema,
+    responses: {
+      200: sendFeishuMessageResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Send a Feishu message via an organization custom app"
+  }
+});
+var FEISHU_FILE_UPLOAD_MAX_BYTES = 30 * 1024 * 1024;
+var feishuResourceTypeSchema = external_exports.enum(["file", "image"]);
+var integrationsFeishuDownloadFileContract = c.router({
+  download: {
+    method: "GET",
+    path: "/api/zero/integrations/feishu/download-file",
+    headers: authHeadersSchema,
+    query: external_exports.object({
+      installation_id: external_exports.string().uuid().optional(),
+      message_id: external_exports.string().min(1, "Message ID is required"),
+      file_key: external_exports.string().min(1, "File key is required"),
+      type: feishuResourceTypeSchema
+    }),
+    responses: {
+      200: c.otherResponse({
+        contentType: "application/octet-stream",
+        body: external_exports.unknown()
+      }),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      413: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Download a file from a Feishu message"
+  }
+});
+var feishuUploadInitBodySchema = external_exports.object({
+  filename: external_exports.string().min(1, "Filename is required").max(255),
+  contentType: external_exports.string().min(1, "Content type is required").max(200),
+  length: external_exports.number().int().positive("File length must be a positive integer").max(
+    FEISHU_FILE_UPLOAD_MAX_BYTES,
+    `File must not exceed ${FEISHU_FILE_UPLOAD_MAX_BYTES} bytes`
+  ),
+  ...directUploadCapabilityShape
+});
+var feishuUploadInitResponseSchema = external_exports.object({
+  uploadId: external_exports.string().uuid(),
+  uploadUrl: external_exports.string(),
+  fileUrl: external_exports.string(),
+  filename: external_exports.string(),
+  contentType: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  ...directUploadResponseShape
+});
+var integrationsFeishuUploadInitContract = c.router({
+  init: {
+    method: "POST",
+    path: "/api/zero/integrations/feishu/upload-file/init",
+    headers: authHeadersSchema,
+    body: feishuUploadInitBodySchema,
+    responses: {
+      200: feishuUploadInitResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "Get a pre-signed upload URL for Feishu file delivery"
+  }
+});
+var feishuUploadCompleteBodySchema = external_exports.object({
+  uploadId: external_exports.string().uuid("Upload ID must be a UUID"),
+  installationId: external_exports.string().uuid().optional(),
+  chat: external_exports.string().min(1, "Chat ID is required").optional(),
+  user: external_exports.string().min(1, "Feishu open ID is required").optional(),
+  replyToMessageId: external_exports.string().min(1, "Message ID is required").optional(),
+  replyInThread: external_exports.boolean().optional(),
+  contentType: external_exports.string().min(1).max(200).optional()
+}).refine(
+  (body) => {
+    return [body.chat, body.user, body.replyToMessageId].filter(Boolean).length === 1;
+  },
+  {
+    message: "Exactly one of chat, user, or replyToMessageId is required",
+    path: ["chat"]
+  }
+).refine(
+  (body) => {
+    return !body.replyInThread || Boolean(body.replyToMessageId);
+  },
+  {
+    message: "replyInThread requires replyToMessageId",
+    path: ["replyInThread"]
+  }
+);
+var feishuUploadCompleteResponseSchema = external_exports.object({
+  messageId: external_exports.string(),
+  chatId: external_exports.string().nullable(),
+  fileKey: external_exports.string(),
+  filename: external_exports.string(),
+  mimetype: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  url: external_exports.string()
+});
+var integrationsFeishuUploadCompleteContract = c.router({
+  complete: {
+    method: "POST",
+    path: "/api/zero/integrations/feishu/upload-file/complete",
+    headers: authHeadersSchema,
+    body: feishuUploadCompleteBodySchema,
+    responses: {
+      200: feishuUploadCompleteResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      413: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Finalize Feishu file upload and send it to a conversation"
+  }
+});
+var sendTelegramMessageBodySchema = external_exports.object({
+  botId: external_exports.string().min(1, "Bot ID is required"),
+  chatId: external_exports.string().min(1, "Chat ID is required"),
+  text: external_exports.string().min(1, "Message text is required"),
+  replyToMessageId: external_exports.number().int().positive().optional(),
+  messageThreadId: external_exports.number().int().positive().optional()
+});
+var sendTelegramMessageResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  messageId: external_exports.number().int(),
+  chatId: external_exports.string()
+});
+var integrationsTelegramMessageContract = c.router({
+  sendMessage: {
+    method: "POST",
+    path: "/api/zero/integrations/telegram/message",
+    headers: authHeadersSchema,
+    body: sendTelegramMessageBodySchema,
+    responses: {
+      200: sendTelegramMessageResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Send a Telegram message via org bot token"
+  }
+});
+var teamsAdaptiveCardSchema = external_exports.object({
+  type: external_exports.literal("AdaptiveCard"),
+  version: external_exports.string().min(1),
+  body: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).optional(),
+  actions: external_exports.array(external_exports.record(external_exports.string(), external_exports.unknown())).optional()
+}).passthrough();
+var sendTeamsMessageBodySchema = external_exports.object({
+  conversationId: external_exports.string().min(1, "Conversation ID is required").optional(),
+  user: external_exports.string().min(1, "Teams user ID is required").optional(),
+  text: external_exports.string().min(1, "Message text is required").optional(),
+  activityId: external_exports.string().min(1, "Activity ID is required").optional(),
+  card: teamsAdaptiveCardSchema.optional()
+}).refine(
+  (body) => {
+    return Boolean(body.conversationId) !== Boolean(body.user);
+  },
+  {
+    message: "Exactly one of conversationId or user is required",
+    path: ["conversationId"]
+  }
+).refine(
+  (body) => {
+    return Boolean(body.text) || Boolean(body.card);
+  },
+  {
+    message: "Message text or card is required",
+    path: ["text"]
+  }
+).refine(
+  (body) => {
+    return !(body.user && body.activityId);
+  },
+  {
+    message: "activityId can only be used with conversationId",
+    path: ["activityId"]
+  }
+);
+var sendTeamsMessageResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  activityId: external_exports.string().optional(),
+  conversationId: external_exports.string()
+});
+var integrationsTeamsMessageContract = c.router({
+  sendMessage: {
+    method: "POST",
+    path: "/api/zero/integrations/teams/message",
+    headers: authHeadersSchema,
+    body: sendTeamsMessageBodySchema,
+    responses: {
+      200: sendTeamsMessageResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Send a Microsoft Teams message via org bot"
+  }
+});
+var sendPhoneMessageBodySchema = external_exports.object({
+  agentphoneAgentId: external_exports.string().min(1, "AgentPhone agent ID is required").optional(),
+  toNumber: external_exports.string().min(1, "Phone number is required"),
+  text: external_exports.string().min(1, "Message text is required")
+});
+var sendPhoneMessageResponseSchema = external_exports.object({
+  ok: external_exports.literal(true),
+  messageId: external_exports.string(),
+  channel: external_exports.string().nullable(),
+  toNumber: external_exports.string()
+});
+var integrationsPhoneMessageContract = c.router({
+  sendMessage: {
+    method: "POST",
+    path: "/api/zero/integrations/phone/message",
+    headers: authHeadersSchema,
+    body: sendPhoneMessageBodySchema,
+    responses: {
+      200: sendPhoneMessageResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Send an AgentPhone message"
+  }
+});
+var phoneDownloadFileQuerySchema = external_exports.object({
+  file_id: external_exports.string().min(1, "file_id query parameter is required")
+});
+var integrationsPhoneDownloadFileContract = c.router({
+  download: {
+    method: "GET",
+    path: "/api/zero/integrations/phone/download-file",
+    headers: authHeadersSchema,
+    query: phoneDownloadFileQuerySchema,
+    responses: {
+      200: c.type(),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      413: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Download an AgentPhone media attachment"
+  }
+});
+var telegramBotTokenStatusSchema = external_exports.enum(["valid", "invalid", "unknown"]);
+var telegramConnectedUserSchema = external_exports.object({
+  telegramUserId: external_exports.string(),
+  telegramUsername: external_exports.string().nullable(),
+  telegramDisplayName: external_exports.string().nullable()
+});
+var telegramBotListItemSchema = external_exports.object({
+  id: external_exports.string(),
+  kind: external_exports.enum(["custom", "official"]).optional(),
+  username: external_exports.string().nullable(),
+  agent: external_exports.object({ id: external_exports.string(), name: external_exports.string() }).nullable(),
+  isOwner: external_exports.boolean(),
+  isConnected: external_exports.boolean(),
+  connectedUser: telegramConnectedUserSchema.nullable().optional(),
+  tokenStatus: telegramBotTokenStatusSchema,
+  official: external_exports.object({
+    configured: external_exports.boolean(),
+    usesDefaultAgent: external_exports.boolean(),
+    linkedTelegramUserId: external_exports.string().nullable()
+  }).optional()
+});
+var listTelegramBotsResponseSchema = external_exports.object({
+  bots: external_exports.array(telegramBotListItemSchema)
+});
+var integrationsTelegramBotListContract = c.router({
+  listBots: {
+    method: "GET",
+    path: "/api/zero/integrations/telegram/bots",
+    headers: authHeadersSchema,
+    responses: {
+      200: listTelegramBotsResponseSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "List Telegram bots available in the authenticated user's org"
+  }
+});
+var slackUploadInitBodySchema = external_exports.object({
+  filename: external_exports.string().min(1, "Filename is required"),
+  length: external_exports.number().int().positive("File length must be a positive integer"),
+  ...directUploadCapabilityShape,
+  canonical: external_exports.object({
+    operationId: external_exports.string().uuid(),
+    contentType: external_exports.string().min(1).max(200),
+    checksumSha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+    channel: external_exports.string().min(1, "Channel ID is required"),
+    threadTs: external_exports.string().optional(),
+    title: external_exports.string().optional(),
+    initialComment: external_exports.string().optional()
+  }).optional()
+});
+var directSlackUploadInitResponseSchema = external_exports.object({
+  uploadUrl: external_exports.string(),
+  fileId: external_exports.string()
+});
+var canonicalSlackUploadInitResponseSchema = external_exports.object({
+  kind: external_exports.literal("canonical"),
+  assetId: external_exports.string().uuid(),
+  operationId: external_exports.string().uuid(),
+  uploadUrl: external_exports.string().url().optional(),
+  url: external_exports.string().url(),
+  ...directUploadResponseShape
+});
+var slackUploadInitResponseSchema = external_exports.union([
+  directSlackUploadInitResponseSchema,
+  canonicalSlackUploadInitResponseSchema
+]);
+var integrationsSlackUploadInitContract = c.router({
+  init: {
+    method: "POST",
+    path: "/api/zero/integrations/slack/upload-file/init",
+    headers: authHeadersSchema,
+    body: slackUploadInitBodySchema,
+    responses: {
+      200: slackUploadInitResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get a pre-signed Slack upload URL via org bot token"
+  }
+});
+var slackUploadMaterializeBodySchema = external_exports.object({
+  assetId: external_exports.string().uuid(),
+  operationId: external_exports.string().uuid()
+});
+var slackUploadMaterializeResponseSchema = external_exports.object({
+  assetId: external_exports.string().uuid(),
+  url: external_exports.string().url(),
+  delivery: external_exports.discriminatedUnion("status", [
+    external_exports.object({
+      status: external_exports.literal("pending"),
+      uploadUrl: external_exports.string(),
+      fileId: external_exports.string()
+    }),
+    external_exports.object({
+      status: external_exports.literal("delivered"),
+      fileId: external_exports.string(),
+      permalink: external_exports.string()
+    }),
+    external_exports.object({
+      status: external_exports.literal("failed"),
+      message: external_exports.string(),
+      retryable: external_exports.boolean()
+    })
+  ])
+});
+var integrationsSlackUploadMaterializeContract = c.router({
+  materialize: {
+    method: "POST",
+    path: "/api/zero/integrations/slack/upload-file/materialize",
+    headers: authHeadersSchema,
+    body: slackUploadMaterializeBodySchema,
+    responses: {
+      200: slackUploadMaterializeResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Materialize a canonical Slack publication before delivery"
+  }
+});
+var telegramUploadInitBodySchema = external_exports.object({
+  filename: external_exports.string().min(1, "Filename is required").max(255),
+  contentType: external_exports.string().min(1, "Content type is required").max(200),
+  length: external_exports.number().int().positive("File length must be a positive integer"),
+  ...directUploadCapabilityShape
+});
+var telegramUploadInitResponseSchema = external_exports.object({
+  uploadId: external_exports.string().uuid(),
+  uploadUrl: external_exports.string(),
+  fileUrl: external_exports.string(),
+  filename: external_exports.string(),
+  contentType: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  ...directUploadResponseShape
+});
+var integrationsTelegramUploadInitContract = c.router({
+  init: {
+    method: "POST",
+    path: "/api/zero/integrations/telegram/upload-file/init",
+    headers: authHeadersSchema,
+    body: telegramUploadInitBodySchema,
+    responses: {
+      200: telegramUploadInitResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "Get a pre-signed upload URL for Telegram file delivery"
+  }
+});
+var teamsUploadInitBodySchema = external_exports.object({
+  filename: external_exports.string().min(1, "Filename is required").max(255),
+  contentType: external_exports.string().min(1, "Content type is required").max(200),
+  length: external_exports.number().int().positive("File length must be a positive integer"),
+  ...directUploadCapabilityShape
+});
+var teamsUploadInitResponseSchema = external_exports.object({
+  uploadId: external_exports.string().uuid(),
+  uploadUrl: external_exports.string(),
+  fileUrl: external_exports.string(),
+  filename: external_exports.string(),
+  contentType: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  ...directUploadResponseShape
+});
+var integrationsTeamsUploadInitContract = c.router({
+  init: {
+    method: "POST",
+    path: "/api/zero/integrations/teams/upload-file/init",
+    headers: authHeadersSchema,
+    body: teamsUploadInitBodySchema,
+    responses: {
+      200: teamsUploadInitResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "Get a pre-signed upload URL for Microsoft Teams file delivery"
+  }
+});
+var telegramUploadCompleteBodySchema = external_exports.object({
+  uploadId: external_exports.string().uuid("Upload ID must be a UUID"),
+  botId: external_exports.string().min(1, "Bot ID is required"),
+  chatId: external_exports.string().min(1, "Chat ID is required"),
+  contentType: external_exports.string().min(1).max(200).optional(),
+  caption: external_exports.string().max(1024).optional(),
+  messageThreadId: external_exports.number().int().positive().optional()
+});
+var telegramUploadCompleteResponseSchema = external_exports.object({
+  messageId: external_exports.number().int(),
+  chatId: external_exports.string(),
+  fileId: external_exports.string().optional(),
+  filename: external_exports.string(),
+  mimetype: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  url: external_exports.string()
+});
+var integrationsTelegramUploadCompleteContract = c.router({
+  complete: {
+    method: "POST",
+    path: "/api/zero/integrations/telegram/upload-file/complete",
+    headers: authHeadersSchema,
+    body: telegramUploadCompleteBodySchema,
+    responses: {
+      200: telegramUploadCompleteResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Finalize Telegram file upload and send it to a chat"
+  }
+});
+var teamsUploadCompleteBodySchema = external_exports.object({
+  uploadId: external_exports.string().uuid("Upload ID must be a UUID"),
+  conversationId: external_exports.string().min(1, "Conversation ID is required"),
+  activityId: external_exports.string().min(1, "Activity ID is required").optional(),
+  contentType: external_exports.string().min(1).max(200).optional(),
+  text: external_exports.string().max(4e3).optional()
+});
+var teamsUploadCompleteResponseSchema = external_exports.object({
+  activityId: external_exports.string().optional(),
+  conversationId: external_exports.string(),
+  filename: external_exports.string(),
+  mimetype: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  url: external_exports.string()
+});
+var integrationsTeamsUploadCompleteContract = c.router({
+  complete: {
+    method: "POST",
+    path: "/api/zero/integrations/teams/upload-file/complete",
+    headers: authHeadersSchema,
+    body: teamsUploadCompleteBodySchema,
+    responses: {
+      200: teamsUploadCompleteResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Finalize Microsoft Teams file upload and send it to a conversation"
+  }
+});
+var githubUploadInitBodySchema = external_exports.object({
+  filename: external_exports.string().min(1, "Filename is required").max(255),
+  contentType: external_exports.string().min(1, "Content type is required").max(200),
+  length: external_exports.number().int().positive("File length must be a positive integer"),
+  ...directUploadCapabilityShape
+});
+var githubUploadInitResponseSchema = external_exports.object({
+  uploadId: external_exports.string().uuid(),
+  uploadUrl: external_exports.string(),
+  fileUrl: external_exports.string(),
+  filename: external_exports.string(),
+  contentType: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  ...directUploadResponseShape
+});
+var integrationsGithubUploadInitContract = c.router({
+  init: {
+    method: "POST",
+    path: "/api/zero/integrations/github/upload-file/init",
+    headers: authHeadersSchema,
+    body: githubUploadInitBodySchema,
+    responses: {
+      200: githubUploadInitResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Get a pre-signed upload URL for GitHub file delivery"
+  }
+});
+var githubUploadCompleteBodySchema = external_exports.object({
+  uploadId: external_exports.string().uuid("Upload ID must be a UUID"),
+  repo: external_exports.string().min(1, "Repository is required").regex(/^[^/\s]+\/[^/\s]+$/, "Repository must be owner/name"),
+  issueNumber: external_exports.number().int().positive("Issue or pull request number must be positive"),
+  contentType: external_exports.string().min(1).max(200).optional(),
+  caption: external_exports.string().max(65536).optional()
+});
+var githubUploadCompleteResponseSchema = external_exports.object({
+  commentId: external_exports.string(),
+  repo: external_exports.string(),
+  issueNumber: external_exports.number().int(),
+  filename: external_exports.string(),
+  mimetype: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  url: external_exports.string()
+});
+var integrationsGithubUploadCompleteContract = c.router({
+  complete: {
+    method: "POST",
+    path: "/api/zero/integrations/github/upload-file/complete",
+    headers: authHeadersSchema,
+    body: githubUploadCompleteBodySchema,
+    responses: {
+      200: githubUploadCompleteResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      502: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Finalize GitHub file upload and post it to an issue or PR"
+  }
+});
+var phoneUploadInitBodySchema = external_exports.object({
+  filename: external_exports.string().min(1, "Filename is required").max(255),
+  contentType: external_exports.string().min(1, "Content type is required").max(200),
+  length: external_exports.number().int().positive("File length must be a positive integer"),
+  ...directUploadCapabilityShape
+});
+var phoneUploadInitResponseSchema = external_exports.object({
+  uploadId: external_exports.string().uuid(),
+  uploadUrl: external_exports.string(),
+  fileUrl: external_exports.string(),
+  filename: external_exports.string(),
+  contentType: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  ...directUploadResponseShape
+});
+var integrationsPhoneUploadInitContract = c.router({
+  init: {
+    method: "POST",
+    path: "/api/zero/integrations/phone/upload-file/init",
+    headers: authHeadersSchema,
+    body: phoneUploadInitBodySchema,
+    responses: {
+      200: phoneUploadInitResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema
+    },
+    summary: "Get a pre-signed upload URL for AgentPhone file delivery"
+  }
+});
+var phoneUploadCompleteBodySchema = external_exports.object({
+  uploadId: external_exports.string().uuid("Upload ID must be a UUID"),
+  agentphoneAgentId: external_exports.string().min(1, "AgentPhone agent ID is required").optional(),
+  toNumber: external_exports.string().min(1, "Phone number is required"),
+  contentType: external_exports.string().min(1).max(200).optional(),
+  caption: external_exports.string().max(1024).optional()
+});
+var phoneUploadCompleteResponseSchema = external_exports.object({
+  messageId: external_exports.string(),
+  channel: external_exports.string().nullable(),
+  toNumber: external_exports.string(),
+  filename: external_exports.string(),
+  mimetype: external_exports.string(),
+  size: external_exports.number().int().nonnegative(),
+  url: external_exports.string()
+});
+var integrationsPhoneUploadCompleteContract = c.router({
+  complete: {
+    method: "POST",
+    path: "/api/zero/integrations/phone/upload-file/complete",
+    headers: authHeadersSchema,
+    body: phoneUploadCompleteBodySchema,
+    responses: {
+      200: phoneUploadCompleteResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema,
+      502: apiErrorSchema
+    },
+    summary: "Finalize AgentPhone file upload and send it to a phone handle"
+  }
+});
+var slackUploadCompleteBodySchema = external_exports.object({
+  fileId: external_exports.string().min(1, "File ID is required"),
+  channel: external_exports.string().min(1, "Channel ID is required"),
+  threadTs: external_exports.string().optional(),
+  title: external_exports.string().optional(),
+  initialComment: external_exports.string().optional(),
+  canonicalAssetId: external_exports.string().uuid().optional(),
+  operationId: external_exports.string().uuid().optional(),
+  uploadError: external_exports.string().max(2e3).optional()
+});
+var slackUploadCompleteResponseSchema = external_exports.object({
+  fileId: external_exports.string(),
+  permalink: external_exports.string(),
+  assetId: external_exports.string().uuid().optional(),
+  assetUrl: external_exports.string().url().optional(),
+  deliveryStatus: external_exports.enum(["delivered", "failed"]).optional(),
+  deliveryError: external_exports.string().optional()
+});
+var integrationsSlackUploadCompleteContract = c.router({
+  complete: {
+    method: "POST",
+    path: "/api/zero/integrations/slack/upload-file/complete",
+    headers: authHeadersSchema,
+    body: slackUploadCompleteBodySchema,
+    responses: {
+      200: slackUploadCompleteResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      403: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Finalize Slack file upload and share to channel"
+  }
+});
+
+export {
+  integrationsSlackMessageContract,
+  integrationsFeishuMessageContract,
+  FEISHU_FILE_UPLOAD_MAX_BYTES,
+  integrationsFeishuUploadInitContract,
+  integrationsFeishuUploadCompleteContract,
+  integrationsTelegramMessageContract,
+  integrationsTeamsMessageContract,
+  integrationsPhoneMessageContract,
+  integrationsTelegramBotListContract,
+  integrationsSlackUploadInitContract,
+  integrationsSlackUploadMaterializeContract,
+  integrationsTelegramUploadInitContract,
+  integrationsTeamsUploadInitContract,
+  integrationsTelegramUploadCompleteContract,
+  integrationsTeamsUploadCompleteContract,
+  integrationsGithubUploadInitContract,
+  integrationsGithubUploadCompleteContract,
+  integrationsPhoneUploadInitContract,
+  integrationsPhoneUploadCompleteContract,
+  integrationsSlackUploadCompleteContract
+};
+//# sourceMappingURL=chunk-PFWBO2VK.js.map