@avallon-labs/mcp 0.0.0

package/dist/index.js

@@ -0,0 +1,3839 @@
+#!/usr/bin/env node
+
+// src/generated/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/generated/http-client.ts
+var getListAgentsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/agents?${stringifiedParams}` : `/v1/agents`;
+};
+var listAgents = async (params, options) => {
+  return customFetch(getListAgentsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCreateAgentUrl = () => {
+  return `/v1/agents`;
+};
+var createAgent = async (createAgentBody, options) => {
+  return customFetch(getCreateAgentUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createAgentBody)
+  });
+};
+var getGetAgentUrl = (id) => {
+  return `/v1/agents/${id}`;
+};
+var getAgent = async (id, options) => {
+  return customFetch(getGetAgentUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getAddToolsToAgentUrl = (id) => {
+  return `/v1/agents/${id}/tools`;
+};
+var addToolsToAgent = async (id, addToolsToAgentBody, options) => {
+  return customFetch(getAddToolsToAgentUrl(id), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(addToolsToAgentBody)
+  });
+};
+var getDeleteToolsFromAgentUrl = (id) => {
+  return `/v1/agents/${id}/tools`;
+};
+var deleteToolsFromAgent = async (id, deleteToolsFromAgentBody, options) => {
+  return customFetch(
+    getDeleteToolsFromAgentUrl(id),
+    {
+      ...options,
+      method: "DELETE",
+      headers: { "Content-Type": "application/json", ...options?.headers },
+      body: JSON.stringify(deleteToolsFromAgentBody)
+    }
+  );
+};
+var getGetAgentPromptUrl = (id) => {
+  return `/v1/agents/${id}/prompt`;
+};
+var getAgentPrompt = async (id, options) => {
+  return customFetch(getGetAgentPromptUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getUpdateAgentModelsUrl = (id) => {
+  return `/v1/agents/${id}/models`;
+};
+var updateAgentModels = async (id, updateAgentModelsBody, options) => {
+  return customFetch(getUpdateAgentModelsUrl(id), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(updateAgentModelsBody)
+  });
+};
+var getUpdateCallControlsUrl = (id) => {
+  return `/v1/agents/${id}/call-controls`;
+};
+var updateCallControls = async (id, updateCallControlsBody, options) => {
+  return customFetch(getUpdateCallControlsUrl(id), {
+    ...options,
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(updateCallControlsBody)
+  });
+};
+var getScheduleJobUrl = (id) => {
+  return `/v1/agents/${id}/jobs`;
+};
+var scheduleJob = async (id, scheduleJobBody, options) => {
+  return customFetch(getScheduleJobUrl(id), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(scheduleJobBody)
+  });
+};
+var getListJobsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/agents/jobs?${stringifiedParams}` : `/v1/agents/jobs`;
+};
+var listJobs = async (params, options) => {
+  return customFetch(getListJobsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCancelJobUrl = (id) => {
+  return `/v1/agents/jobs/${id}/cancel`;
+};
+var cancelJob = async (id, options) => {
+  return customFetch(getCancelJobUrl(id), {
+    ...options,
+    method: "POST"
+  });
+};
+var getListApiKeysUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/platform/api-keys?${stringifiedParams}` : `/platform/api-keys`;
+};
+var listApiKeys = async (params, options) => {
+  return customFetch(getListApiKeysUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCreateApiKeyUrl = () => {
+  return `/platform/api-keys`;
+};
+var createApiKey = async (createApiKeyBody, options) => {
+  return customFetch(getCreateApiKeyUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createApiKeyBody)
+  });
+};
+var getRevokeApiKeyUrl = (id) => {
+  return `/platform/api-keys/${id}/revoke`;
+};
+var revokeApiKey = async (id, options) => {
+  return customFetch(getRevokeApiKeyUrl(id), {
+    ...options,
+    method: "POST"
+  });
+};
+var getCreateArtifactUrl = () => {
+  return `/v1/artifacts`;
+};
+var createArtifact = async (createArtifactBody, options) => {
+  return customFetch(getCreateArtifactUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createArtifactBody)
+  });
+};
+var getListArtifactsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/artifacts?${stringifiedParams}` : `/v1/artifacts`;
+};
+var listArtifacts = async (params, options) => {
+  return customFetch(getListArtifactsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetArtifactUrl = (id) => {
+  return `/v1/artifacts/${id}`;
+};
+var getArtifact = async (id, options) => {
+  return customFetch(getGetArtifactUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetArtifactMetadataKeysUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/artifacts/metadata/keys?${stringifiedParams}` : `/v1/artifacts/metadata/keys`;
+};
+var getArtifactMetadataKeys = async (params, options) => {
+  return customFetch(
+    getGetArtifactMetadataKeysUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getSignUpUrl = () => {
+  return `/v1/auth/sign-up`;
+};
+var signUp = async (signUpBody, options) => {
+  return customFetch(getSignUpUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(signUpBody)
+  });
+};
+var getSignInUrl = () => {
+  return `/v1/auth/sign-in`;
+};
+var signIn = async (signInBody, options) => {
+  return customFetch(getSignInUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(signInBody)
+  });
+};
+var getRefreshTokenUrl = () => {
+  return `/v1/auth/refresh-token`;
+};
+var refreshToken = async (refreshTokenBody, options) => {
+  return customFetch(getRefreshTokenUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(refreshTokenBody)
+  });
+};
+var getGetOAuthUrlUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/auth/oauth-url?${stringifiedParams}` : `/v1/auth/oauth-url`;
+};
+var getOAuthUrl = async (params, options) => {
+  return customFetch(getGetOAuthUrlUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getListCallsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/calls?${stringifiedParams}` : `/v1/calls`;
+};
+var listCalls = async (params, options) => {
+  return customFetch(getListCallsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCallUrl = (id, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/calls/${id}?${stringifiedParams}` : `/v1/calls/${id}`;
+};
+var getCall = async (id, params, options) => {
+  return customFetch(getGetCallUrl(id, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCallEvaluationUrl = (id) => {
+  return `/v1/calls/${id}/evaluation`;
+};
+var getCallEvaluation = async (id, options) => {
+  return customFetch(getGetCallEvaluationUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetCallAnalyticsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/calls/analytics?${stringifiedParams}` : `/v1/calls/analytics`;
+};
+var getCallAnalytics = async (params, options) => {
+  return customFetch(getGetCallAnalyticsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCreateCallFeedbackUrl = (id) => {
+  return `/v1/calls/${id}/feedback`;
+};
+var createCallFeedback = async (id, createFeedbackRequest, options) => {
+  return customFetch(getCreateCallFeedbackUrl(id), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createFeedbackRequest)
+  });
+};
+var getListCallFeedbackUrl = (id, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/calls/${id}/feedback?${stringifiedParams}` : `/v1/calls/${id}/feedback`;
+};
+var listCallFeedback = async (id, params, options) => {
+  return customFetch(
+    getListCallFeedbackUrl(id, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getDeleteCallFeedbackUrl = (id, feedbackId) => {
+  return `/v1/calls/${id}/feedback/${feedbackId}`;
+};
+var deleteCallFeedback = async (id, feedbackId, options) => {
+  return customFetch(
+    getDeleteCallFeedbackUrl(id, feedbackId),
+    {
+      ...options,
+      method: "DELETE"
+    }
+  );
+};
+var getCreateClaimUrl = () => {
+  return `/v1/claims`;
+};
+var createClaim = async (options) => {
+  return customFetch(getCreateClaimUrl(), {
+    ...options,
+    method: "POST"
+  });
+};
+var getListClaimsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/claims?${stringifiedParams}` : `/v1/claims`;
+};
+var listClaims = async (params, options) => {
+  return customFetch(getListClaimsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetClaimDetailUrl = (id) => {
+  return `/v1/claims/${id}`;
+};
+var getClaimDetail = async (id, options) => {
+  return customFetch(getGetClaimDetailUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCheckEmailUsernameAvailabilityUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/email-agents/availability?${stringifiedParams}` : `/v1/email-agents/availability`;
+};
+var checkEmailUsernameAvailability = async (params, options) => {
+  return customFetch(
+    getCheckEmailUsernameAvailabilityUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getCreateEmailAgentUrl = () => {
+  return `/v1/email-agents`;
+};
+var createEmailAgent = async (createEmailAgentBody, options) => {
+  return customFetch(getCreateEmailAgentUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createEmailAgentBody)
+  });
+};
+var getListEmailAgentsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/email-agents?${stringifiedParams}` : `/v1/email-agents`;
+};
+var listEmailAgents = async (params, options) => {
+  return customFetch(getListEmailAgentsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getUpdateEmailAgentUrl = (id) => {
+  return `/v1/email-agents/${id}`;
+};
+var updateEmailAgent = async (id, updateEmailAgentBody, options) => {
+  return customFetch(getUpdateEmailAgentUrl(id), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(updateEmailAgentBody)
+  });
+};
+var getCreateEmailUrl = () => {
+  return `/v1/emails`;
+};
+var createEmail = async (createEmailBody, options) => {
+  return customFetch(getCreateEmailUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createEmailBody)
+  });
+};
+var getListEmailsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/emails?${stringifiedParams}` : `/v1/emails`;
+};
+var listEmails = async (params, options) => {
+  return customFetch(getListEmailsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetEmailUrl = (emailId) => {
+  return `/v1/emails/${emailId}`;
+};
+var getEmail = async (emailId, options) => {
+  return customFetch(getGetEmailUrl(emailId), {
+    ...options,
+    method: "GET"
+  });
+};
+var getListExtractorJobsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/extractor-jobs?${stringifiedParams}` : `/v1/extractor-jobs`;
+};
+var listExtractorJobs = async (params, options) => {
+  return customFetch(
+    getListExtractorJobsUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getCreateExtractorJobUrl = () => {
+  return `/v1/extractor-jobs`;
+};
+var createExtractorJob = async (createExtractorJobBody, options) => {
+  return customFetch(getCreateExtractorJobUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createExtractorJobBody)
+  });
+};
+var getGetExtractorJobUrl = (id) => {
+  return `/v1/extractor-jobs/${id}`;
+};
+var getExtractorJob = async (id, options) => {
+  return customFetch(getGetExtractorJobUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCancelExtractorJobUrl = (id) => {
+  return `/v1/extractor-jobs/${id}/cancel`;
+};
+var cancelExtractorJob = async (id, options) => {
+  return customFetch(getCancelExtractorJobUrl(id), {
+    ...options,
+    method: "POST"
+  });
+};
+var getCreateExtractorUrl = () => {
+  return `/v1/extractors`;
+};
+var createExtractor = async (createExtractorBody, options) => {
+  return customFetch(getCreateExtractorUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createExtractorBody)
+  });
+};
+var getListExtractorsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/extractors?${stringifiedParams}` : `/v1/extractors`;
+};
+var listExtractors = async (params, options) => {
+  return customFetch(getListExtractorsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetExtractorUrl = (id) => {
+  return `/v1/extractors/${id}`;
+};
+var getExtractor = async (id, options) => {
+  return customFetch(getGetExtractorUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getUpdateExtractorUrl = (id) => {
+  return `/v1/extractors/${id}`;
+};
+var updateExtractor = async (id, updateExtractorBody, options) => {
+  return customFetch(getUpdateExtractorUrl(id), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(updateExtractorBody)
+  });
+};
+var getGetExtractUrl = (id) => {
+  return `/v1/extracts/${id}`;
+};
+var getExtract = async (id, options) => {
+  return customFetch(getGetExtractUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getListExtractsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/extracts?${stringifiedParams}` : `/v1/extracts`;
+};
+var listExtracts = async (params, options) => {
+  return customFetch(getListExtractsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getGetProfileUrl = () => {
+  return `/v1/profile`;
+};
+var getProfile = async (options) => {
+  return customFetch(getGetProfileUrl(), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCreateToolUrl = () => {
+  return `/v1/tools`;
+};
+var createTool = async (createToolBody, options) => {
+  return customFetch(getCreateToolUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createToolBody)
+  });
+};
+var getListToolsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/tools?${stringifiedParams}` : `/v1/tools`;
+};
+var listTools = async (params, options) => {
+  return customFetch(getListToolsUrl(params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getExecuteCodeUrl = (id) => {
+  return `/v1/tools/${id}/execute`;
+};
+var executeCode = async (id, executeCodeBody, options) => {
+  return customFetch(getExecuteCodeUrl(id), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(executeCodeBody)
+  });
+};
+var getGetToolUrl = (id) => {
+  return `/v1/tools/${id}`;
+};
+var getTool = async (id, options) => {
+  return customFetch(getGetToolUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getUpdateToolUrl = (id) => {
+  return `/v1/tools/${id}`;
+};
+var updateTool = async (id, updateToolBody, options) => {
+  return customFetch(getUpdateToolUrl(id), {
+    ...options,
+    method: "PATCH",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(updateToolBody)
+  });
+};
+var getUploadFileUrl = () => {
+  return `/v1/upload-file`;
+};
+var uploadFile = async (uploadFileBody, options) => {
+  return customFetch(getUploadFileUrl(), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(uploadFileBody)
+  });
+};
+var getCreateAgentWebhookUrl = (id) => {
+  return `/v1/agents/${id}/webhooks`;
+};
+var createAgentWebhook = async (id, createAgentWebhookBody, options) => {
+  return customFetch(getCreateAgentWebhookUrl(id), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(createAgentWebhookBody)
+  });
+};
+var getListAgentWebhooksUrl = (id) => {
+  return `/v1/agents/${id}/webhooks`;
+};
+var listAgentWebhooks = async (id, options) => {
+  return customFetch(getListAgentWebhooksUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCreateEmailAgentWebhookUrl = (id) => {
+  return `/v1/email-agents/${id}/webhooks`;
+};
+var createEmailAgentWebhook = async (id, createEmailAgentWebhookBody, options) => {
+  return customFetch(
+    getCreateEmailAgentWebhookUrl(id),
+    {
+      ...options,
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...options?.headers },
+      body: JSON.stringify(createEmailAgentWebhookBody)
+    }
+  );
+};
+var getListEmailAgentWebhooksUrl = (id) => {
+  return `/v1/email-agents/${id}/webhooks`;
+};
+var listEmailAgentWebhooks = async (id, options) => {
+  return customFetch(
+    getListEmailAgentWebhooksUrl(id),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getCreateExtractorWebhookUrl = (id) => {
+  return `/v1/extractors/${id}/webhooks`;
+};
+var createExtractorWebhook = async (id, createExtractorWebhookBody, options) => {
+  return customFetch(
+    getCreateExtractorWebhookUrl(id),
+    {
+      ...options,
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...options?.headers },
+      body: JSON.stringify(createExtractorWebhookBody)
+    }
+  );
+};
+var getListWebhooksUrl = (id) => {
+  return `/v1/extractors/${id}/webhooks`;
+};
+var listWebhooks = async (id, options) => {
+  return customFetch(getListWebhooksUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getDeleteWebhookUrl = (id) => {
+  return `/v1/webhooks/${id}`;
+};
+var deleteWebhook = async (id, options) => {
+  return customFetch(getDeleteWebhookUrl(id), {
+    ...options,
+    method: "DELETE"
+  });
+};
+var getGetWebhookUrl = (id) => {
+  return `/v1/webhooks/${id}`;
+};
+var getWebhook = async (id, options) => {
+  return customFetch(getGetWebhookUrl(id), {
+    ...options,
+    method: "GET"
+  });
+};
+var getListWebhookDeliveriesUrl = (id, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/webhooks/${id}/deliveries?${stringifiedParams}` : `/v1/webhooks/${id}/deliveries`;
+};
+var listWebhookDeliveries = async (id, params, options) => {
+  return customFetch(
+    getListWebhookDeliveriesUrl(id, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getTestWebhookUrl = (id) => {
+  return `/v1/webhooks/${id}/test`;
+};
+var testWebhook = async (id, options) => {
+  return customFetch(getTestWebhookUrl(id), {
+    ...options,
+    method: "POST"
+  });
+};
+
+// src/generated/handlers.ts
+var listAgentsHandler = async (args) => {
+  const res = await listAgents(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createAgentHandler = async (args) => {
+  const res = await createAgent(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getAgentHandler = async (args) => {
+  const res = await getAgent(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var addToolsToAgentHandler = async (args) => {
+  const res = await addToolsToAgent(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var deleteToolsFromAgentHandler = async (args) => {
+  const res = await deleteToolsFromAgent(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getAgentPromptHandler = async (args) => {
+  const res = await getAgentPrompt(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var updateAgentModelsHandler = async (args) => {
+  const res = await updateAgentModels(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var updateCallControlsHandler = async (args) => {
+  const res = await updateCallControls(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var scheduleJobHandler = async (args) => {
+  const res = await scheduleJob(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listJobsHandler = async (args) => {
+  const res = await listJobs(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var cancelJobHandler = async (args) => {
+  const res = await cancelJob(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listApiKeysHandler = async (args) => {
+  const res = await listApiKeys(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createApiKeyHandler = async (args) => {
+  const res = await createApiKey(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var revokeApiKeyHandler = async (args) => {
+  const res = await revokeApiKey(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createArtifactHandler = async (args) => {
+  const res = await createArtifact(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listArtifactsHandler = async (args) => {
+  const res = await listArtifacts(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getArtifactHandler = async (args) => {
+  const res = await getArtifact(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getArtifactMetadataKeysHandler = async (args) => {
+  const res = await getArtifactMetadataKeys(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var signUpHandler = async (args) => {
+  const res = await signUp(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var signInHandler = async (args) => {
+  const res = await signIn(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var refreshTokenHandler = async (args) => {
+  const res = await refreshToken(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getOAuthUrlHandler = async (args) => {
+  const res = await getOAuthUrl(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listCallsHandler = async (args) => {
+  const res = await listCalls(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getCallHandler = async (args) => {
+  const res = await getCall(args.pathParams.id, args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getCallEvaluationHandler = async (args) => {
+  const res = await getCallEvaluation(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getCallAnalyticsHandler = async (args) => {
+  const res = await getCallAnalytics(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createCallFeedbackHandler = async (args) => {
+  const res = await createCallFeedback(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listCallFeedbackHandler = async (args) => {
+  const res = await listCallFeedback(args.pathParams.id, args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var deleteCallFeedbackHandler = async (args) => {
+  const res = await deleteCallFeedback(
+    args.pathParams.id,
+    args.pathParams.feedbackId
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createClaimHandler = async () => {
+  const res = await createClaim();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listClaimsHandler = async (args) => {
+  const res = await listClaims(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getClaimDetailHandler = async (args) => {
+  const res = await getClaimDetail(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var checkEmailUsernameAvailabilityHandler = async (args) => {
+  const res = await checkEmailUsernameAvailability(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createEmailAgentHandler = async (args) => {
+  const res = await createEmailAgent(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listEmailAgentsHandler = async (args) => {
+  const res = await listEmailAgents(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var updateEmailAgentHandler = async (args) => {
+  const res = await updateEmailAgent(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createEmailHandler = async (args) => {
+  const res = await createEmail(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listEmailsHandler = async (args) => {
+  const res = await listEmails(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getEmailHandler = async (args) => {
+  const res = await getEmail(args.pathParams.emailId);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listExtractorJobsHandler = async (args) => {
+  const res = await listExtractorJobs(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createExtractorJobHandler = async (args) => {
+  const res = await createExtractorJob(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getExtractorJobHandler = async (args) => {
+  const res = await getExtractorJob(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var cancelExtractorJobHandler = async (args) => {
+  const res = await cancelExtractorJob(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createExtractorHandler = async (args) => {
+  const res = await createExtractor(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listExtractorsHandler = async (args) => {
+  const res = await listExtractors(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getExtractorHandler = async (args) => {
+  const res = await getExtractor(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var updateExtractorHandler = async (args) => {
+  const res = await updateExtractor(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getExtractHandler = async (args) => {
+  const res = await getExtract(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listExtractsHandler = async (args) => {
+  const res = await listExtracts(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getProfileHandler = async () => {
+  const res = await getProfile();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createToolHandler = async (args) => {
+  const res = await createTool(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listToolsHandler = async (args) => {
+  const res = await listTools(args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var executeCodeHandler = async (args) => {
+  const res = await executeCode(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getToolHandler = async (args) => {
+  const res = await getTool(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var updateToolHandler = async (args) => {
+  const res = await updateTool(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var uploadFileHandler = async (args) => {
+  const res = await uploadFile(args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createAgentWebhookHandler = async (args) => {
+  const res = await createAgentWebhook(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listAgentWebhooksHandler = async (args) => {
+  const res = await listAgentWebhooks(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createEmailAgentWebhookHandler = async (args) => {
+  const res = await createEmailAgentWebhook(
+    args.pathParams.id,
+    args.bodyParams
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listEmailAgentWebhooksHandler = async (args) => {
+  const res = await listEmailAgentWebhooks(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var createExtractorWebhookHandler = async (args) => {
+  const res = await createExtractorWebhook(args.pathParams.id, args.bodyParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listWebhooksHandler = async (args) => {
+  const res = await listWebhooks(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var deleteWebhookHandler = async (args) => {
+  const res = await deleteWebhook(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getWebhookHandler = async (args) => {
+  const res = await getWebhook(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var listWebhookDeliveriesHandler = async (args) => {
+  const res = await listWebhookDeliveries(args.pathParams.id, args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var testWebhookHandler = async (args) => {
+  const res = await testWebhook(args.pathParams.id);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+
+// src/generated/tool-schemas.zod.ts
+import { z as zod } from "zod";
+var ListAgentsQueryParams = zod.object({
+  agent_name: zod.string().optional().describe("Filter by exact agent name")
+});
+var listAgentsResponseTotalMin = -9007199254740991;
+var listAgentsResponseTotalMax = 9007199254740991;
+var ListAgentsResponse = zod.object({
+  agents: zod.array(
+    zod.object({
+      id: zod.string(),
+      tenant_id: zod.string(),
+      agent_name: zod.string(),
+      direction: zod.enum(["INBOUND", "OUTBOUND"]),
+      llm_model: zod.enum([
+        "GPT4.1",
+        "AZURE-GPT4o",
+        "AZURE-GPT4.1",
+        "GPT-5",
+        "GPT-5-low",
+        "GPT-5-high",
+        "GPT-5.1-chat-latest",
+        "GPT-5.1-no-reasoning",
+        "GEMINI-1.5-flash",
+        "GEMINI-2.5-flash",
+        "GEMINI-2.5-flash-lite",
+        "GEMINI-3-flash",
+        "CLAUDE-sonnet-4.6",
+        "CLAUDE-haiku-4.5"
+      ]),
+      tts_provider: zod.enum(["elevenlabs", "cartesia", "google"]),
+      tts_model: zod.enum([
+        "eleven_flash_v2_5",
+        "eleven_turbo_v2_5",
+        "sonic-3",
+        "chirp_3"
+      ]),
+      language: zod.enum(["en-US", "de-DE"]),
+      tts_voice_id: zod.string().describe("Voice ID from the TTS provider"),
+      stt_model: zod.enum([
+        "DEEPGRAM-NOVA-2-GENERAL",
+        "DEEPGRAM-NOVA-3-GENERAL",
+        "AWS-TRANSCRIBE",
+        "ELEVENLABS-SCRIBE-V2-REALTIME"
+      ]),
+      transfer_phone_number: zod.union([zod.string(), zod.null()]),
+      background_sounds: zod.enum(["enabled", "disabled"]),
+      created_at: zod.string().datetime({}),
+      updated_at: zod.string().datetime({}),
+      phone_number: zod.union([zod.string(), zod.null()]),
+      dial_pad: zod.boolean(),
+      end_call: zod.boolean()
+    })
+  ),
+  total: zod.number().min(listAgentsResponseTotalMin).max(listAgentsResponseTotalMax).describe("Total number of agents")
+});
+var CreateAgentBody = zod.object({
+  agent_name: zod.string().min(1).describe("Name for the agent"),
+  direction: zod.enum(["OUTBOUND", "INBOUND"]).describe("Call direction the agent handles"),
+  llm_model: zod.enum([
+    "GPT4.1",
+    "AZURE-GPT4o",
+    "AZURE-GPT4.1",
+    "GPT-5",
+    "GPT-5-low",
+    "GPT-5-high",
+    "GPT-5.1-chat-latest",
+    "GPT-5.1-no-reasoning",
+    "GEMINI-1.5-flash",
+    "GEMINI-2.5-flash",
+    "GEMINI-2.5-flash-lite",
+    "GEMINI-3-flash",
+    "CLAUDE-sonnet-4.6",
+    "CLAUDE-haiku-4.5"
+  ]).describe("LLM model for conversation"),
+  tts_provider: zod.enum(["elevenlabs", "cartesia", "google"]).describe("Text-to-speech provider"),
+  tts_model: zod.enum(["eleven_flash_v2_5", "eleven_turbo_v2_5", "sonic-3", "chirp_3"]).describe("Text-to-speech model"),
+  tts_voice_id: zod.union([
+    zod.union([
+      zod.enum(["Achernar", "Achird"]),
+      zod.enum(["v3V1d2rk6528UrLKRuy8"])
+    ]),
+    zod.enum([
+      "5c42302c-194b-4d0c-ba1a-8cb485c84ab9",
+      "e8e5fffb-252c-436d-b842-8879b84445b6",
+      "f786b574-daa5-4673-aa0c-cbe3e8534c02",
+      "8d8ce8c9-44a4-46c4-b10f-9a927b99a853",
+      "5ee9feff-1265-424a-9d7f-8e4d431a12c7",
+      "b9de4a89-2257-424b-94c2-db18ba68c81a",
+      "b0a1cdc7-e0d3-4d48-900d-7a936762c77b"
+    ])
+  ]).describe("Voice ID from the TTS provider"),
+  stt_model: zod.enum([
+    "DEEPGRAM-NOVA-2-GENERAL",
+    "DEEPGRAM-NOVA-3-GENERAL",
+    "AWS-TRANSCRIBE",
+    "ELEVENLABS-SCRIBE-V2-REALTIME"
+  ]).describe("Speech-to-text model"),
+  transfer_phone_number: zod.union([zod.string(), zod.null()]).describe("Phone number to transfer calls to"),
+  phone_number_id: zod.string().optional().describe("ID of phone number to assign to agent"),
+  language: zod.enum(["en-US", "de-DE"]).describe("Language for the agent"),
+  dial_pad: zod.boolean().optional().describe("Whether the agent supports DTMF dial pad input"),
+  end_call: zod.boolean().optional().describe("Whether the agent can end the call")
+});
+var GetAgentParams = zod.object({
+  id: zod.string().min(1).describe("Agent ID")
+});
+var GetAgentResponse = zod.object({
+  agent: zod.object({
+    id: zod.string(),
+    tenant_id: zod.string(),
+    agent_name: zod.string(),
+    direction: zod.enum(["INBOUND", "OUTBOUND"]),
+    llm_model: zod.enum([
+      "GPT4.1",
+      "AZURE-GPT4o",
+      "AZURE-GPT4.1",
+      "GPT-5",
+      "GPT-5-low",
+      "GPT-5-high",
+      "GPT-5.1-chat-latest",
+      "GPT-5.1-no-reasoning",
+      "GEMINI-1.5-flash",
+      "GEMINI-2.5-flash",
+      "GEMINI-2.5-flash-lite",
+      "GEMINI-3-flash",
+      "CLAUDE-sonnet-4.6",
+      "CLAUDE-haiku-4.5"
+    ]),
+    tts_provider: zod.enum(["elevenlabs", "cartesia", "google"]),
+    tts_model: zod.enum([
+      "eleven_flash_v2_5",
+      "eleven_turbo_v2_5",
+      "sonic-3",
+      "chirp_3"
+    ]),
+    language: zod.enum(["en-US", "de-DE"]),
+    tts_voice_id: zod.string().describe("Voice ID from the TTS provider"),
+    stt_model: zod.enum([
+      "DEEPGRAM-NOVA-2-GENERAL",
+      "DEEPGRAM-NOVA-3-GENERAL",
+      "AWS-TRANSCRIBE",
+      "ELEVENLABS-SCRIBE-V2-REALTIME"
+    ]),
+    transfer_phone_number: zod.union([zod.string(), zod.null()]),
+    background_sounds: zod.enum(["enabled", "disabled"]),
+    created_at: zod.string().datetime({}),
+    updated_at: zod.string().datetime({}),
+    phone_number: zod.union([zod.string(), zod.null()]),
+    dial_pad: zod.boolean(),
+    end_call: zod.boolean()
+  })
+});
+var addToolsToAgentPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var AddToolsToAgentParams = zod.object({
+  id: zod.string().uuid().regex(addToolsToAgentPathIdRegExp)
+});
+var addToolsToAgentBodyToolIdsItemRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var AddToolsToAgentBody = zod.object({
+  tool_ids: zod.array(
+    zod.string().uuid().regex(addToolsToAgentBodyToolIdsItemRegExp)
+  )
+});
+var AddToolsToAgentResponse = zod.object({
+  agent: zod.object({
+    id: zod.string(),
+    tenant_id: zod.string(),
+    agent_name: zod.string(),
+    direction: zod.enum(["INBOUND", "OUTBOUND"]),
+    llm_model: zod.enum([
+      "GPT4.1",
+      "AZURE-GPT4o",
+      "AZURE-GPT4.1",
+      "GPT-5",
+      "GPT-5-low",
+      "GPT-5-high",
+      "GPT-5.1-chat-latest",
+      "GPT-5.1-no-reasoning",
+      "GEMINI-1.5-flash",
+      "GEMINI-2.5-flash",
+      "GEMINI-2.5-flash-lite",
+      "GEMINI-3-flash",
+      "CLAUDE-sonnet-4.6",
+      "CLAUDE-haiku-4.5"
+    ]),
+    tts_provider: zod.enum(["elevenlabs", "cartesia", "google"]),
+    tts_model: zod.enum([
+      "eleven_flash_v2_5",
+      "eleven_turbo_v2_5",
+      "sonic-3",
+      "chirp_3"
+    ]),
+    language: zod.enum(["en-US", "de-DE"]),
+    tts_voice_id: zod.string().describe("Voice ID from the TTS provider"),
+    stt_model: zod.enum([
+      "DEEPGRAM-NOVA-2-GENERAL",
+      "DEEPGRAM-NOVA-3-GENERAL",
+      "AWS-TRANSCRIBE",
+      "ELEVENLABS-SCRIBE-V2-REALTIME"
+    ]),
+    transfer_phone_number: zod.union([zod.string(), zod.null()]),
+    background_sounds: zod.enum(["enabled", "disabled"]),
+    created_at: zod.string().datetime({}),
+    updated_at: zod.string().datetime({}),
+    phone_number: zod.union([zod.string(), zod.null()]),
+    dial_pad: zod.boolean(),
+    end_call: zod.boolean()
+  })
+});
+var deleteToolsFromAgentPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var DeleteToolsFromAgentParams = zod.object({
+  id: zod.string().uuid().regex(deleteToolsFromAgentPathIdRegExp)
+});
+var deleteToolsFromAgentBodyToolIdsItemRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var DeleteToolsFromAgentBody = zod.object({
+  tool_ids: zod.array(
+    zod.string().uuid().regex(deleteToolsFromAgentBodyToolIdsItemRegExp)
+  )
+});
+var DeleteToolsFromAgentResponse = zod.object({
+  agent: zod.object({
+    id: zod.string(),
+    tenant_id: zod.string(),
+    agent_name: zod.string(),
+    direction: zod.enum(["INBOUND", "OUTBOUND"]),
+    llm_model: zod.enum([
+      "GPT4.1",
+      "AZURE-GPT4o",
+      "AZURE-GPT4.1",
+      "GPT-5",
+      "GPT-5-low",
+      "GPT-5-high",
+      "GPT-5.1-chat-latest",
+      "GPT-5.1-no-reasoning",
+      "GEMINI-1.5-flash",
+      "GEMINI-2.5-flash",
+      "GEMINI-2.5-flash-lite",
+      "GEMINI-3-flash",
+      "CLAUDE-sonnet-4.6",
+      "CLAUDE-haiku-4.5"
+    ]),
+    tts_provider: zod.enum(["elevenlabs", "cartesia", "google"]),
+    tts_model: zod.enum([
+      "eleven_flash_v2_5",
+      "eleven_turbo_v2_5",
+      "sonic-3",
+      "chirp_3"
+    ]),
+    language: zod.enum(["en-US", "de-DE"]),
+    tts_voice_id: zod.string().describe("Voice ID from the TTS provider"),
+    stt_model: zod.enum([
+      "DEEPGRAM-NOVA-2-GENERAL",
+      "DEEPGRAM-NOVA-3-GENERAL",
+      "AWS-TRANSCRIBE",
+      "ELEVENLABS-SCRIBE-V2-REALTIME"
+    ]),
+    transfer_phone_number: zod.union([zod.string(), zod.null()]),
+    background_sounds: zod.enum(["enabled", "disabled"]),
+    created_at: zod.string().datetime({}),
+    updated_at: zod.string().datetime({}),
+    phone_number: zod.union([zod.string(), zod.null()]),
+    dial_pad: zod.boolean(),
+    end_call: zod.boolean()
+  })
+});
+var GetAgentPromptParams = zod.object({
+  id: zod.string().min(1)
+});
+var GetAgentPromptResponse = zod.object({
+  prompt: zod.string().describe("The agent system prompt"),
+  placeholders: zod.array(zod.string()).describe("Available placeholder variables")
+});
+var UpdateAgentModelsParams = zod.object({
+  id: zod.string().min(1)
+});
+var UpdateAgentModelsBody = zod.object({
+  llm_model: zod.enum([
+    "GPT4.1",
+    "AZURE-GPT4o",
+    "AZURE-GPT4.1",
+    "GPT-5",
+    "GPT-5-low",
+    "GPT-5-high",
+    "GPT-5.1-chat-latest",
+    "GPT-5.1-no-reasoning",
+    "GEMINI-1.5-flash",
+    "GEMINI-2.5-flash",
+    "GEMINI-2.5-flash-lite",
+    "GEMINI-3-flash",
+    "CLAUDE-sonnet-4.6",
+    "CLAUDE-haiku-4.5"
+  ]),
+  tts_provider: zod.enum(["elevenlabs", "cartesia", "google"]),
+  tts_model: zod.enum([
+    "eleven_flash_v2_5",
+    "eleven_turbo_v2_5",
+    "sonic-3",
+    "chirp_3"
+  ]),
+  tts_voice_id: zod.union([
+    zod.union([
+      zod.enum(["Achernar", "Achird"]),
+      zod.enum(["v3V1d2rk6528UrLKRuy8"])
+    ]),
+    zod.enum([
+      "5c42302c-194b-4d0c-ba1a-8cb485c84ab9",
+      "e8e5fffb-252c-436d-b842-8879b84445b6",
+      "f786b574-daa5-4673-aa0c-cbe3e8534c02",
+      "8d8ce8c9-44a4-46c4-b10f-9a927b99a853",
+      "5ee9feff-1265-424a-9d7f-8e4d431a12c7",
+      "b9de4a89-2257-424b-94c2-db18ba68c81a",
+      "b0a1cdc7-e0d3-4d48-900d-7a936762c77b"
+    ])
+  ]),
+  stt_model: zod.enum([
+    "DEEPGRAM-NOVA-2-GENERAL",
+    "DEEPGRAM-NOVA-3-GENERAL",
+    "AWS-TRANSCRIBE",
+    "ELEVENLABS-SCRIBE-V2-REALTIME"
+  ]),
+  language: zod.enum(["en-US", "de-DE"])
+});
+var UpdateAgentModelsResponse = zod.object({
+  agent: zod.object({
+    id: zod.string(),
+    tenant_id: zod.string(),
+    agent_name: zod.string(),
+    direction: zod.enum(["INBOUND", "OUTBOUND"]),
+    llm_model: zod.enum([
+      "GPT4.1",
+      "AZURE-GPT4o",
+      "AZURE-GPT4.1",
+      "GPT-5",
+      "GPT-5-low",
+      "GPT-5-high",
+      "GPT-5.1-chat-latest",
+      "GPT-5.1-no-reasoning",
+      "GEMINI-1.5-flash",
+      "GEMINI-2.5-flash",
+      "GEMINI-2.5-flash-lite",
+      "GEMINI-3-flash",
+      "CLAUDE-sonnet-4.6",
+      "CLAUDE-haiku-4.5"
+    ]),
+    tts_provider: zod.enum(["elevenlabs", "cartesia", "google"]),
+    tts_model: zod.enum([
+      "eleven_flash_v2_5",
+      "eleven_turbo_v2_5",
+      "sonic-3",
+      "chirp_3"
+    ]),
+    language: zod.enum(["en-US", "de-DE"]),
+    tts_voice_id: zod.string().describe("Voice ID from the TTS provider"),
+    stt_model: zod.enum([
+      "DEEPGRAM-NOVA-2-GENERAL",
+      "DEEPGRAM-NOVA-3-GENERAL",
+      "AWS-TRANSCRIBE",
+      "ELEVENLABS-SCRIBE-V2-REALTIME"
+    ]),
+    transfer_phone_number: zod.union([zod.string(), zod.null()]),
+    background_sounds: zod.enum(["enabled", "disabled"]),
+    created_at: zod.string().datetime({}),
+    updated_at: zod.string().datetime({}),
+    phone_number: zod.union([zod.string(), zod.null()]),
+    dial_pad: zod.boolean(),
+    end_call: zod.boolean()
+  })
+});
+var updateCallControlsPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var UpdateCallControlsParams = zod.object({
+  id: zod.string().uuid().regex(updateCallControlsPathIdRegExp)
+});
+var UpdateCallControlsBody = zod.object({
+  dial_pad: zod.boolean().optional(),
+  end_call: zod.boolean().optional(),
+  transfer_phone_number: zod.union([zod.string(), zod.null()]).optional()
+});
+var UpdateCallControlsResponse = zod.object({
+  agent: zod.object({
+    id: zod.string(),
+    tenant_id: zod.string(),
+    agent_name: zod.string(),
+    direction: zod.enum(["INBOUND", "OUTBOUND"]),
+    llm_model: zod.enum([
+      "GPT4.1",
+      "AZURE-GPT4o",
+      "AZURE-GPT4.1",
+      "GPT-5",
+      "GPT-5-low",
+      "GPT-5-high",
+      "GPT-5.1-chat-latest",
+      "GPT-5.1-no-reasoning",
+      "GEMINI-1.5-flash",
+      "GEMINI-2.5-flash",
+      "GEMINI-2.5-flash-lite",
+      "GEMINI-3-flash",
+      "CLAUDE-sonnet-4.6",
+      "CLAUDE-haiku-4.5"
+    ]),
+    tts_provider: zod.enum(["elevenlabs", "cartesia", "google"]),
+    tts_model: zod.enum([
+      "eleven_flash_v2_5",
+      "eleven_turbo_v2_5",
+      "sonic-3",
+      "chirp_3"
+    ]),
+    language: zod.enum(["en-US", "de-DE"]),
+    tts_voice_id: zod.string().describe("Voice ID from the TTS provider"),
+    stt_model: zod.enum([
+      "DEEPGRAM-NOVA-2-GENERAL",
+      "DEEPGRAM-NOVA-3-GENERAL",
+      "AWS-TRANSCRIBE",
+      "ELEVENLABS-SCRIBE-V2-REALTIME"
+    ]),
+    transfer_phone_number: zod.union([zod.string(), zod.null()]),
+    background_sounds: zod.enum(["enabled", "disabled"]),
+    created_at: zod.string().datetime({}),
+    updated_at: zod.string().datetime({}),
+    phone_number: zod.union([zod.string(), zod.null()]),
+    dial_pad: zod.boolean(),
+    end_call: zod.boolean()
+  })
+});
+var scheduleJobPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var ScheduleJobParams = zod.object({
+  id: zod.string().uuid().regex(scheduleJobPathIdRegExp)
+});
+var scheduleJobBodyScheduleWindowMinutesMin = 10;
+var scheduleJobBodyScheduleWindowMinutesMax = 9007199254740991;
+var scheduleJobBodyPayloadDefault = {};
+var scheduleJobBodyTriggerImmediatelyDefault = false;
+var ScheduleJobBody = zod.object({
+  scheduled_at: zod.string(),
+  schedule_window_minutes: zod.number().min(scheduleJobBodyScheduleWindowMinutesMin).max(scheduleJobBodyScheduleWindowMinutesMax).optional(),
+  destination_phone_number: zod.string(),
+  payload: zod.record(zod.string(), zod.unknown()).default(scheduleJobBodyPayloadDefault),
+  metadata: zod.record(zod.string(), zod.unknown()).optional(),
+  trigger_immediately: zod.boolean().default(scheduleJobBodyTriggerImmediatelyDefault)
+});
+var ScheduleJobResponse = zod.object({
+  id: zod.string(),
+  agent_id: zod.string(),
+  tenant_id: zod.string(),
+  scheduled_at: zod.string().datetime({}),
+  schedule_window_minutes: zod.number(),
+  destination_phone_number: zod.string(),
+  payload: zod.record(zod.string(), zod.unknown()),
+  metadata: zod.union([zod.record(zod.string(), zod.unknown()), zod.null()]),
+  status: zod.enum([
+    "pending",
+    "queued",
+    "in_progress",
+    "completed",
+    "canceled"
+  ]),
+  created_at: zod.string().datetime({})
+});
+var listJobsQueryAgentRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var listJobsQueryCountDefault = 50;
+var listJobsQueryCountMax = 100;
+var listJobsQueryOffsetDefault = 0;
+var listJobsQueryOffsetMin = 0;
+var listJobsQueryOffsetMax = 9007199254740991;
+var ListJobsQueryParams = zod.object({
+  agent: zod.string().uuid().regex(listJobsQueryAgentRegExp).optional(),
+  count: zod.number().min(1).max(listJobsQueryCountMax).default(listJobsQueryCountDefault),
+  offset: zod.number().min(listJobsQueryOffsetMin).max(listJobsQueryOffsetMax).default(listJobsQueryOffsetDefault),
+  status: zod.array(
+    zod.enum(["pending", "queued", "in_progress", "completed", "canceled"])
+  ),
+  scheduled_after: zod.string().datetime({}).optional(),
+  scheduled_before: zod.string().datetime({}).optional()
+});
+var ListJobsResponseItem = zod.object({
+  id: zod.string(),
+  agent_id: zod.string(),
+  tenant_id: zod.string(),
+  scheduled_at: zod.string().datetime({}),
+  schedule_window_minutes: zod.number(),
+  destination_phone_number: zod.string(),
+  payload: zod.record(zod.string(), zod.unknown()),
+  metadata: zod.union([zod.record(zod.string(), zod.unknown()), zod.null()]),
+  status: zod.enum([
+    "pending",
+    "queued",
+    "in_progress",
+    "completed",
+    "canceled"
+  ]),
+  created_at: zod.string().datetime({})
+});
+var ListJobsResponse = zod.array(ListJobsResponseItem);
+var CancelJobParams = zod.object({
+  id: zod.string().min(1)
+});
+var CancelJobResponse = zod.object({
+  id: zod.string(),
+  agent_id: zod.string(),
+  tenant_id: zod.string(),
+  scheduled_at: zod.string().datetime({}),
+  schedule_window_minutes: zod.number(),
+  destination_phone_number: zod.string(),
+  payload: zod.record(zod.string(), zod.unknown()),
+  metadata: zod.union([zod.record(zod.string(), zod.unknown()), zod.null()]),
+  status: zod.enum([
+    "pending",
+    "queued",
+    "in_progress",
+    "completed",
+    "canceled"
+  ]),
+  created_at: zod.string().datetime({})
+});
+var ListApiKeysQueryParams = zod.object({
+  include_revoked: zod.enum(["true", "false"]).optional().describe("Include revoked keys in the response")
+});
+var ListApiKeysResponse = zod.object({
+  data: zod.array(
+    zod.object({
+      id: zod.string().describe("Unique identifier for the API key"),
+      name: zod.string().describe("Human-readable name for the API key"),
+      key_prefix: zod.string().describe("First 12 characters of the key (e.g. ak_live_abc1)"),
+      last_used_at: zod.string().datetime({}).optional().describe("Last usage timestamp, if ever used"),
+      expires_at: zod.string().datetime({}).optional().describe("Expiration date, if set"),
+      revoked_at: zod.string().datetime({}).optional().describe("Revocation timestamp, if revoked"),
+      created_at: zod.string().datetime({}).describe("Creation timestamp"),
+      updated_at: zod.string().datetime({}).describe("Last update timestamp")
+    })
+  ),
+  count: zod.number().describe("Total number of keys returned")
+});
+var createApiKeyBodyNameMax = 100;
+var createApiKeyBodyEnvironmentDefault = `live`;
+var CreateApiKeyBody = zod.object({
+  name: zod.string().min(1).max(createApiKeyBodyNameMax).describe("Human-readable name for the API key"),
+  expires_at: zod.string().datetime({}).optional().describe("Optional expiration date (ISO 8601)"),
+  environment: zod.enum(["test", "live"]).default(createApiKeyBodyEnvironmentDefault).describe("Target environment for the key")
+});
+var revokeApiKeyPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var RevokeApiKeyParams = zod.object({
+  id: zod.string().uuid().regex(revokeApiKeyPathIdRegExp).describe("The API key ID to revoke")
+});
+var RevokeApiKeyResponse = zod.object({
+  message: zod.string().describe("Confirmation message")
+});
+var createArtifactBodyFileBase64Max = 9e6;
+var CreateArtifactBody = zod.object({
+  document_name: zod.string().min(1),
+  file_base64: zod.string().min(1).max(createArtifactBodyFileBase64Max),
+  processing_options: zod.object({
+    file_password: zod.string().optional(),
+    file_splitting_enabled: zod.boolean().optional()
+  }).optional(),
+  created_at_document: zod.string().datetime({}).optional(),
+  metadata: zod.record(zod.string(), zod.unknown()).optional()
+});
+var CreateArtifactResponseItem = zod.object({
+  artifact_id: zod.string(),
+  message_id: zod.string().describe("Processing message identifier"),
+  status: zod.string()
+});
+var CreateArtifactResponse = zod.array(CreateArtifactResponseItem);
+var listArtifactsQueryCountDefault = 50;
+var listArtifactsQueryCountMax = 100;
+var listArtifactsQueryOffsetDefault = 0;
+var listArtifactsQueryOffsetMin = 0;
+var listArtifactsQuerySortByDefault = `created_at`;
+var listArtifactsQuerySortOrderDefault = `desc`;
+var ListArtifactsQueryParams = zod.object({
+  count: zod.number().min(1).max(listArtifactsQueryCountMax).default(listArtifactsQueryCountDefault),
+  offset: zod.number().min(listArtifactsQueryOffsetMin).default(listArtifactsQueryOffsetDefault),
+  sort_by: zod.enum(["created_at", "updated_at", "document_name"]).default(listArtifactsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listArtifactsQuerySortOrderDefault),
+  document_name_query: zod.string().optional(),
+  created_after: zod.string().datetime({}).optional(),
+  created_before: zod.string().datetime({}).optional()
+});
+var ListArtifactsResponseItem = zod.object({
+  id: zod.string(),
+  document_name: zod.string(),
+  metadata: zod.record(zod.string(), zod.unknown()),
+  created_at: zod.string().datetime({}),
+  created_at_document: zod.union([zod.string(), zod.null()]),
+  updated_at: zod.string().datetime({}),
+  has_content: zod.boolean()
+});
+var ListArtifactsResponse = zod.array(ListArtifactsResponseItem);
+var GetArtifactParams = zod.object({
+  id: zod.string().min(1)
+});
+var GetArtifactResponse = zod.object({
+  data: zod.object({
+    id: zod.string(),
+    document_name: zod.string(),
+    file_url: zod.union([zod.string(), zod.null()]),
+    metadata: zod.record(zod.string(), zod.unknown()),
+    created_at: zod.string().datetime({}),
+    created_at_document: zod.union([zod.string(), zod.null()]),
+    updated_at: zod.string().datetime({}),
+    content_md: zod.union([zod.string(), zod.null()])
+  })
+});
+var getArtifactMetadataKeysQueryLimitDefault = 100;
+var getArtifactMetadataKeysQueryLimitMax = 500;
+var GetArtifactMetadataKeysQueryParams = zod.object({
+  limit: zod.number().min(1).max(getArtifactMetadataKeysQueryLimitMax).default(getArtifactMetadataKeysQueryLimitDefault)
+});
+var GetArtifactMetadataKeysResponse = zod.object({
+  data: zod.object({
+    keys: zod.array(zod.string()),
+    values: zod.record(zod.string(), zod.array(zod.unknown()))
+  })
+});
+var signUpBodyEmailRegExp = new RegExp(
+  "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+);
+var SignUpBody = zod.object({
+  email: zod.string().email().regex(signUpBodyEmailRegExp),
+  password: zod.string()
+});
+var SignUpResponse = zod.object({});
+var signInBodyThreeEmailRegExp = new RegExp(
+  "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+);
+var SignInBody = zod.union([
+  zod.object({
+    type: zod.literal("password"),
+    email: zod.string(),
+    password: zod.string()
+  }),
+  zod.object({
+    type: zod.literal("oauth"),
+    code: zod.string(),
+    verifier: zod.string()
+  }),
+  zod.object({
+    type: zod.literal("email_otp"),
+    email: zod.string().email().regex(signInBodyThreeEmailRegExp),
+    token: zod.string().min(1)
+  })
+]);
+var SignInResponse = zod.object({
+  access_token: zod.string(),
+  refresh_token: zod.string(),
+  expires_at: zod.string().datetime({})
+});
+var RefreshTokenBody = zod.object({
+  access_token: zod.string(),
+  refresh_token: zod.string()
+});
+var RefreshTokenResponse = zod.object({
+  access_token: zod.string(),
+  refresh_token: zod.string(),
+  expires_at: zod.string().datetime({})
+});
+var GetOAuthUrlQueryParams = zod.object({
+  provider: zod.enum(["google", "microsoft"]),
+  redirect_uri: zod.string().url(),
+  code_challenge_method: zod.enum(["plain", "s256"]),
+  code_challenge: zod.string().min(1)
+});
+var GetOAuthUrlResponse = zod.object({
+  url: zod.string().url()
+});
+var listCallsQueryCountDefault = 50;
+var listCallsQueryCountMax = 100;
+var listCallsQueryOffsetDefault = 0;
+var listCallsQueryOffsetMin = 0;
+var listCallsQuerySortByDefault = `started_at`;
+var listCallsQuerySortOrderDefault = `desc`;
+var listCallsQueryCallIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var listCallsQueryAgentIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var listCallsQueryJobIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var ListCallsQueryParams = zod.object({
+  count: zod.number().min(1).max(listCallsQueryCountMax).default(listCallsQueryCountDefault),
+  offset: zod.number().min(listCallsQueryOffsetMin).default(listCallsQueryOffsetDefault),
+  sort_by: zod.enum(["started_at", "ended_at", "created_at"]).default(listCallsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listCallsQuerySortOrderDefault),
+  call_id: zod.string().uuid().regex(listCallsQueryCallIdRegExp).optional(),
+  agent_id: zod.string().uuid().regex(listCallsQueryAgentIdRegExp).optional(),
+  agent_name: zod.string().min(1).optional(),
+  job_id: zod.string().uuid().regex(listCallsQueryJobIdRegExp).optional(),
+  direction: zod.enum(["INBOUND", "OUTBOUND"]).optional(),
+  status: zod.enum(["COMPLETED", "TRANSFERRED", "DISCONNECTED", "UNEXPECTED_SHUTDOWN"]).optional(),
+  started_after: zod.string().datetime({}).optional(),
+  started_before: zod.string().datetime({}).optional(),
+  phone_number: zod.string().min(1).optional()
+});
+var ListCallsResponseItem = zod.object({
+  id: zod.string(),
+  external_call_id: zod.union([zod.string(), zod.null()]),
+  direction: zod.enum(["INBOUND", "OUTBOUND"]),
+  agent_id: zod.string(),
+  job_id: zod.union([zod.string(), zod.null()]),
+  from_phone_number: zod.union([zod.string(), zod.null()]),
+  to_phone_number: zod.union([zod.string(), zod.null()]),
+  started_at: zod.string().datetime({}),
+  ended_at: zod.string().datetime({}),
+  duration_seconds: zod.union([zod.number(), zod.null()]),
+  completion_status: zod.union([
+    zod.string().describe("Call completion status"),
+    zod.null()
+  ]),
+  termination_initiator: zod.union([zod.string(), zod.null()]),
+  disconnect_reason: zod.union([zod.string(), zod.null()]),
+  ended_reason: zod.string(),
+  metadata: zod.union([zod.record(zod.string(), zod.unknown()), zod.null()]),
+  evaluation: zod.union([
+    zod.object({
+      status: zod.string(),
+      score: zod.union([zod.number(), zod.null()]),
+      passed: zod.union([zod.boolean(), zod.null()])
+    }),
+    zod.null()
+  ]),
+  created_at: zod.string().datetime({})
+});
+var ListCallsResponse = zod.array(ListCallsResponseItem);
+var getCallPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var GetCallParams = zod.object({
+  id: zod.string().uuid().regex(getCallPathIdRegExp)
+});
+var GetCallQueryParams = zod.object({
+  include_messages: zod.string().optional()
+});
+var GetCallResponse = zod.object({
+  id: zod.string(),
+  external_call_id: zod.union([zod.string(), zod.null()]),
+  direction: zod.enum(["INBOUND", "OUTBOUND"]),
+  agent_id: zod.string(),
+  job_id: zod.union([zod.string(), zod.null()]),
+  from_phone_number: zod.union([zod.string(), zod.null()]),
+  to_phone_number: zod.union([zod.string(), zod.null()]),
+  started_at: zod.string().datetime({}),
+  ended_at: zod.string().datetime({}),
+  duration_seconds: zod.union([zod.number(), zod.null()]),
+  completion_status: zod.union([
+    zod.string().describe("Call completion status"),
+    zod.null()
+  ]),
+  termination_initiator: zod.union([zod.string(), zod.null()]),
+  disconnect_reason: zod.union([zod.string(), zod.null()]),
+  ended_reason: zod.string(),
+  file_url: zod.union([zod.string(), zod.null()]),
+  metadata: zod.union([zod.record(zod.string(), zod.unknown()), zod.null()]),
+  evaluation: zod.union([
+    zod.object({
+      status: zod.string(),
+      score: zod.union([zod.number(), zod.null()]),
+      passed: zod.union([zod.boolean(), zod.null()])
+    }),
+    zod.null()
+  ]),
+  created_at: zod.string().datetime({}),
+  messages: zod.union([
+    zod.array(
+      zod.object({
+        id: zod.string(),
+        message_type: zod.string(),
+        sequence_number: zod.number(),
+        timestamp_seconds: zod.number(),
+        occurred_at: zod.string(),
+        role: zod.union([zod.string(), zod.null()]),
+        message_text: zod.union([zod.string(), zod.null()]),
+        tool_call_id: zod.union([zod.string(), zod.null()]),
+        tool_name: zod.union([zod.string(), zod.null()]),
+        tool_arguments: zod.union([
+          zod.record(zod.string(), zod.unknown()),
+          zod.null()
+        ]),
+        tool_result: zod.union([
+          zod.record(zod.string(), zod.unknown()),
+          zod.null()
+        ]),
+        metadata: zod.union([
+          zod.record(zod.string(), zod.unknown()),
+          zod.null()
+        ])
+      })
+    ),
+    zod.null()
+  ])
+});
+var getCallEvaluationPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var GetCallEvaluationParams = zod.object({
+  id: zod.string().uuid().regex(getCallEvaluationPathIdRegExp)
+});
+var GetCallEvaluationResponse = zod.object({
+  id: zod.string(),
+  evaluation_status: zod.union([
+    zod.string().describe("Evaluation status"),
+    zod.null()
+  ]),
+  score: zod.union([zod.number(), zod.null()]),
+  passed: zod.union([zod.boolean(), zod.null()]),
+  metrics: zod.array(
+    zod.object({
+      slug: zod.string(),
+      name: zod.string(),
+      question: zod.string(),
+      pass: zod.union([zod.boolean(), zod.null()]),
+      score: zod.union([zod.number(), zod.null()]),
+      explanation: zod.union([zod.string(), zod.null()])
+    })
+  )
+});
+var getCallAnalyticsQueryTimezoneDefault = `UTC`;
+var GetCallAnalyticsQueryParams = zod.object({
+  from: zod.string(),
+  to: zod.string(),
+  timezone: zod.string().default(getCallAnalyticsQueryTimezoneDefault)
+});
+var GetCallAnalyticsResponse = zod.object({
+  summary: zod.object({
+    total_calls: zod.number(),
+    avg_evaluation_score: zod.number(),
+    pass_rate: zod.number(),
+    avg_call_duration: zod.number()
+  }),
+  calls_over_time: zod.array(
+    zod.object({
+      date: zod.string(),
+      calls: zod.number()
+    })
+  ),
+  evaluation_over_time: zod.array(
+    zod.object({
+      date: zod.string(),
+      avg_score: zod.number()
+    })
+  ),
+  score_distribution: zod.array(
+    zod.object({
+      label: zod.string(),
+      count: zod.number()
+    })
+  ),
+  duration_distribution: zod.array(
+    zod.object({
+      label: zod.string(),
+      count: zod.number()
+    })
+  ),
+  metric_performance: zod.array(
+    zod.object({
+      slug: zod.string(),
+      title: zod.string(),
+      avg_score: zod.number(),
+      pass_rate: zod.number(),
+      evaluated: zod.number()
+    })
+  )
+});
+var createCallFeedbackPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var CreateCallFeedbackParams = zod.object({
+  id: zod.string().uuid().regex(createCallFeedbackPathIdRegExp).describe("The call ID")
+});
+var createCallFeedbackBodyMessageIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var createCallFeedbackBodyTextMax = 1e4;
+var CreateCallFeedbackBody = zod.object({
+  message_id: zod.string().uuid().regex(createCallFeedbackBodyMessageIdRegExp).describe("The message ID to attach feedback to"),
+  text: zod.string().min(1).max(createCallFeedbackBodyTextMax).describe("Feedback content")
+});
+var listCallFeedbackPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var ListCallFeedbackParams = zod.object({
+  id: zod.string().uuid().regex(listCallFeedbackPathIdRegExp).describe("The call ID")
+});
+var listCallFeedbackQueryCountDefault = 50;
+var listCallFeedbackQueryCountMax = 100;
+var listCallFeedbackQueryOffsetDefault = 0;
+var listCallFeedbackQueryOffsetMin = 0;
+var listCallFeedbackQuerySortByDefault = `created_at`;
+var listCallFeedbackQuerySortOrderDefault = `asc`;
+var ListCallFeedbackQueryParams = zod.object({
+  count: zod.number().min(1).max(listCallFeedbackQueryCountMax).default(listCallFeedbackQueryCountDefault),
+  offset: zod.number().min(listCallFeedbackQueryOffsetMin).default(listCallFeedbackQueryOffsetDefault),
+  sort_by: zod.enum(["created_at"]).default(listCallFeedbackQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listCallFeedbackQuerySortOrderDefault)
+});
+var listCallFeedbackResponseIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var listCallFeedbackResponseCallIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var listCallFeedbackResponseMessageIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var ListCallFeedbackResponseItem = zod.object({
+  id: zod.string().uuid().regex(listCallFeedbackResponseIdRegExp),
+  call_id: zod.string().uuid().regex(listCallFeedbackResponseCallIdRegExp),
+  message_id: zod.string().uuid().regex(listCallFeedbackResponseMessageIdRegExp),
+  author_email: zod.string(),
+  text: zod.string(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListCallFeedbackResponse = zod.array(ListCallFeedbackResponseItem);
+var deleteCallFeedbackPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var deleteCallFeedbackPathFeedbackIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var DeleteCallFeedbackParams = zod.object({
+  id: zod.string().uuid().regex(deleteCallFeedbackPathIdRegExp).describe("The call ID"),
+  feedbackId: zod.string().uuid().regex(deleteCallFeedbackPathFeedbackIdRegExp).describe("The feedback ID to delete")
+});
+var DeleteCallFeedbackResponse = zod.null();
+var CreateClaimResponse = zod.object({
+  claim_id: zod.string(),
+  created_at: zod.string().datetime({})
+});
+var listClaimsQueryCountDefault = 20;
+var listClaimsQueryCountMax = 100;
+var listClaimsQueryOffsetDefault = 0;
+var listClaimsQueryOffsetMin = 0;
+var listClaimsQuerySortByDefault = `created_at`;
+var listClaimsQuerySortOrderDefault = `desc`;
+var ListClaimsQueryParams = zod.object({
+  count: zod.number().min(1).max(listClaimsQueryCountMax).default(listClaimsQueryCountDefault),
+  offset: zod.number().min(listClaimsQueryOffsetMin).default(listClaimsQueryOffsetDefault),
+  sort_by: zod.enum(["created_at"]).default(listClaimsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listClaimsQuerySortOrderDefault)
+});
+var ListClaimsResponse = zod.object({
+  claims: zod.array(
+    zod.object({
+      id: zod.string(),
+      created_at: zod.string().datetime({}),
+      latest_source: zod.union([zod.unknown(), zod.null()]),
+      job_status: zod.union([
+        zod.string().describe("Extractor job status"),
+        zod.null()
+      ])
+    })
+  ),
+  total: zod.number().describe("do not use. use the property in the meta object instead.")
+});
+var GetClaimDetailParams = zod.object({
+  id: zod.string().min(1)
+});
+var GetClaimDetailResponse = zod.object({
+  claim: zod.object({
+    id: zod.string(),
+    created_at: zod.string().datetime({}),
+    updated_at: zod.string().datetime({})
+  }),
+  sources: zod.array(
+    zod.object({
+      type: zod.string(),
+      direction: zod.string(),
+      id: zod.string(),
+      from: zod.string(),
+      to: zod.array(zod.string()),
+      subject: zod.union([zod.string(), zod.null()]),
+      body_html: zod.union([zod.string(), zod.null()]),
+      received_at: zod.string()
+    })
+  ),
+  artifacts: zod.array(
+    zod.object({
+      id: zod.string(),
+      document_name: zod.string(),
+      created_at: zod.string().datetime({})
+    })
+  ),
+  extractor_job: zod.union([
+    zod.object({
+      id: zod.string(),
+      status: zod.string(),
+      extract_id: zod.union([zod.string(), zod.null()])
+    }),
+    zod.null()
+  ]),
+  extract: zod.union([zod.unknown(), zod.null()])
+});
+var CheckEmailUsernameAvailabilityQueryParams = zod.object({
+  username: zod.string().describe("Email username")
+});
+var CheckEmailUsernameAvailabilityResponse = zod.object({
+  available: zod.boolean().describe("Whether the username is available")
+});
+var createEmailAgentBodyNameMax = 256;
+var createEmailAgentBodyExtractorIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var createEmailAgentBodyAttachmentPasswordOneMax = 2048;
+var CreateEmailAgentBody = zod.object({
+  name: zod.string().min(1).max(createEmailAgentBodyNameMax),
+  extractor_id: zod.string().uuid().regex(createEmailAgentBodyExtractorIdRegExp),
+  attachment_password: zod.union([
+    zod.string().max(createEmailAgentBodyAttachmentPasswordOneMax),
+    zod.null()
+  ]).optional(),
+  pdf_splitting_enabled: zod.boolean().optional(),
+  username: zod.string().optional().describe("Email username")
+});
+var CreateEmailAgentResponse = zod.object({
+  id: zod.string(),
+  name: zod.string(),
+  email_address: zod.string(),
+  extractor_id: zod.string(),
+  has_password: zod.boolean(),
+  pdf_splitting_enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var listEmailAgentsQueryCountDefault = 50;
+var listEmailAgentsQueryCountMax = 100;
+var listEmailAgentsQueryOffsetDefault = 0;
+var listEmailAgentsQueryOffsetMin = 0;
+var listEmailAgentsQuerySortByDefault = `created_at`;
+var listEmailAgentsQuerySortOrderDefault = `desc`;
+var ListEmailAgentsQueryParams = zod.object({
+  count: zod.number().min(1).max(listEmailAgentsQueryCountMax).default(listEmailAgentsQueryCountDefault),
+  offset: zod.number().min(listEmailAgentsQueryOffsetMin).default(listEmailAgentsQueryOffsetDefault),
+  sort_by: zod.enum(["created_at"]).default(listEmailAgentsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listEmailAgentsQuerySortOrderDefault)
+});
+var ListEmailAgentsResponseItem = zod.object({
+  id: zod.string(),
+  name: zod.string(),
+  email_address: zod.string(),
+  extractor_id: zod.string(),
+  has_password: zod.boolean(),
+  pdf_splitting_enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListEmailAgentsResponse = zod.array(ListEmailAgentsResponseItem);
+var updateEmailAgentPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var UpdateEmailAgentParams = zod.object({
+  id: zod.string().uuid().regex(updateEmailAgentPathIdRegExp)
+});
+var UpdateEmailAgentBody = zod.object({
+  pdf_splitting_enabled: zod.boolean().optional()
+});
+var UpdateEmailAgentResponse = zod.object({
+  id: zod.string(),
+  name: zod.string(),
+  email_address: zod.string(),
+  extractor_id: zod.string(),
+  has_password: zod.boolean(),
+  pdf_splitting_enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var createEmailBodyClaimIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var createEmailBodyFromRegExp = new RegExp(
+  "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+);
+var createEmailBodyToItemRegExp = new RegExp(
+  "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+);
+var createEmailBodyCcItemRegExp = new RegExp(
+  "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+);
+var createEmailBodyBccItemRegExp = new RegExp(
+  "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+);
+var CreateEmailBody = zod.object({
+  claim_id: zod.string().uuid().regex(createEmailBodyClaimIdRegExp).optional(),
+  direction: zod.enum(["inbound", "outbound"]),
+  from: zod.string().email().regex(createEmailBodyFromRegExp),
+  to: zod.array(zod.string().email().regex(createEmailBodyToItemRegExp)).min(1),
+  cc: zod.array(zod.string().email().regex(createEmailBodyCcItemRegExp)).optional(),
+  bcc: zod.array(zod.string().email().regex(createEmailBodyBccItemRegExp)).optional(),
+  subject: zod.string().optional(),
+  body_text: zod.string().optional(),
+  body_html: zod.string().optional(),
+  received_at: zod.string()
+});
+var CreateEmailResponse = zod.object({
+  email_id: zod.string(),
+  claim_id: zod.union([zod.string(), zod.null()]),
+  direction: zod.enum(["inbound", "outbound"]),
+  from: zod.string(),
+  to: zod.array(zod.string()),
+  subject: zod.union([zod.string(), zod.null()]),
+  received_at: zod.string(),
+  created_at: zod.string().datetime({})
+});
+var listEmailsQueryAgentIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var listEmailsQuerySenderRegExp = new RegExp(
+  "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+);
+var listEmailsQueryRecipientRegExp = new RegExp(
+  "^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"
+);
+var listEmailsQueryContentMax = 500;
+var listEmailsQueryCountDefault = 50;
+var listEmailsQueryCountMax = 100;
+var listEmailsQueryOffsetDefault = 0;
+var listEmailsQueryOffsetMin = 0;
+var listEmailsQuerySortByDefault = `created_at`;
+var listEmailsQuerySortOrderDefault = `desc`;
+var ListEmailsQueryParams = zod.object({
+  agent_id: zod.string().uuid().regex(listEmailsQueryAgentIdRegExp).optional(),
+  sender: zod.string().email().regex(listEmailsQuerySenderRegExp).optional(),
+  recipient: zod.string().email().regex(listEmailsQueryRecipientRegExp).optional(),
+  content: zod.string().min(1).max(listEmailsQueryContentMax).optional(),
+  count: zod.number().min(1).max(listEmailsQueryCountMax).default(listEmailsQueryCountDefault),
+  offset: zod.number().min(listEmailsQueryOffsetMin).default(listEmailsQueryOffsetDefault),
+  sort_by: zod.enum(["created_at"]).default(listEmailsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listEmailsQuerySortOrderDefault)
+});
+var ListEmailsResponseItem = zod.object({
+  id: zod.string(),
+  email_agent_id: zod.union([zod.string(), zod.null()]),
+  direction: zod.enum(["inbound", "outbound"]),
+  from: zod.string(),
+  to: zod.array(zod.string()),
+  subject: zod.union([zod.string(), zod.null()]),
+  preview: zod.union([zod.string(), zod.null()]),
+  received_at: zod.string(),
+  created_at: zod.string().datetime({})
+});
+var ListEmailsResponse = zod.array(ListEmailsResponseItem);
+var GetEmailParams = zod.object({
+  emailId: zod.string().min(1)
+});
+var GetEmailResponse = zod.object({
+  id: zod.string(),
+  email_agent_id: zod.union([zod.string(), zod.null()]),
+  claim_id: zod.union([zod.string(), zod.null()]),
+  direction: zod.enum(["inbound", "outbound"]),
+  from: zod.string(),
+  to: zod.array(zod.string()),
+  cc: zod.array(zod.string()),
+  bcc: zod.array(zod.string()),
+  subject: zod.union([zod.string(), zod.null()]),
+  body_text: zod.union([zod.string(), zod.null()]),
+  body_html: zod.union([zod.string(), zod.null()]),
+  received_at: zod.string(),
+  created_at: zod.string().datetime({})
+});
+var listExtractorJobsQueryCountDefault = 50;
+var listExtractorJobsQueryCountMax = 100;
+var listExtractorJobsQueryOffsetDefault = 0;
+var listExtractorJobsQueryOffsetMin = 0;
+var listExtractorJobsQuerySortByDefault = `created_at`;
+var listExtractorJobsQuerySortOrderDefault = `desc`;
+var listExtractorJobsQueryExtractorIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var ListExtractorJobsQueryParams = zod.object({
+  count: zod.number().min(1).max(listExtractorJobsQueryCountMax).default(listExtractorJobsQueryCountDefault).describe("Number of results to return"),
+  offset: zod.number().min(listExtractorJobsQueryOffsetMin).default(listExtractorJobsQueryOffsetDefault).describe("Number of results to skip for pagination"),
+  sort_by: zod.enum(["created_at", "started_at", "completed_at"]).default(listExtractorJobsQuerySortByDefault).describe("Field to sort by"),
+  sort_order: zod.enum(["asc", "desc"]).default(listExtractorJobsQuerySortOrderDefault).describe("Sort direction"),
+  status: zod.enum(["queued", "in_progress", "completed", "failed", "canceled"]).optional().describe("Filter by job status"),
+  extractor_type: zod.enum(["basic", "agentic"]).optional().describe("Filter by extractor type"),
+  extractor_id: zod.string().uuid().regex(listExtractorJobsQueryExtractorIdRegExp).optional().describe("Filter by extractor ID"),
+  created_after: zod.string().datetime({}).optional().describe("Filter jobs created after this date (ISO 8601)"),
+  created_before: zod.string().datetime({}).optional().describe("Filter jobs created before this date (ISO 8601)")
+});
+var listExtractorJobsResponseExtractorVersionMin = -9007199254740991;
+var listExtractorJobsResponseExtractorVersionMax = 9007199254740991;
+var ListExtractorJobsResponseItem = zod.object({
+  id: zod.string().describe("Unique job identifier"),
+  extractor_id: zod.string().describe("ID of the extractor that created this job"),
+  extractor_version: zod.number().min(listExtractorJobsResponseExtractorVersionMin).max(listExtractorJobsResponseExtractorVersionMax).describe("Version of the extractor at job creation time"),
+  extractor_name: zod.string().describe("Name of the extractor"),
+  extractor_type: zod.enum(["basic", "agentic"]).describe("Type of extractor"),
+  status: zod.string().describe("Current job status"),
+  scope: zod.record(zod.string(), zod.unknown()).describe("Job scope metadata (e.g. claim_id, email_id)"),
+  created_at: zod.string().describe("ISO 8601 timestamp when the job was created"),
+  started_at: zod.union([zod.string(), zod.null()]).describe("ISO 8601 timestamp when processing started"),
+  completed_at: zod.union([zod.string(), zod.null()]).describe("ISO 8601 timestamp when processing finished"),
+  processing_duration_ms: zod.union([zod.number(), zod.null()]).describe("Processing duration in milliseconds"),
+  extract_id: zod.union([zod.string(), zod.null()]).describe("ID of the resulting extract, if completed"),
+  error: zod.union([zod.string(), zod.null()])
+});
+var ListExtractorJobsResponse = zod.array(
+  ListExtractorJobsResponseItem
+);
+var createExtractorJobBodyExtractorIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var CreateExtractorJobBody = zod.object({
+  extractor_id: zod.string().uuid().regex(createExtractorJobBodyExtractorIdRegExp),
+  scope: zod.record(
+    zod.string(),
+    zod.union([zod.string(), zod.number(), zod.boolean(), zod.null()])
+  )
+});
+var CreateExtractorJobResponse = zod.object({
+  id: zod.string(),
+  extractor_id: zod.string(),
+  extractor_version: zod.number(),
+  scope: zod.record(zod.string(), zod.unknown()),
+  status: zod.string(),
+  created_at: zod.string().datetime({})
+});
+var GetExtractorJobParams = zod.object({
+  id: zod.string().min(1)
+});
+var GetExtractorJobResponse = zod.object({
+  data: zod.object({
+    id: zod.string(),
+    extractor_id: zod.string(),
+    extractor_version: zod.number(),
+    extractor_name: zod.string(),
+    status: zod.string(),
+    scope: zod.record(zod.string(), zod.unknown()),
+    created_at: zod.string().datetime({}),
+    started_at: zod.union([zod.string().datetime({}), zod.null()]),
+    completed_at: zod.union([zod.string(), zod.null()]),
+    processing_duration_ms: zod.union([zod.number(), zod.null()]),
+    extract_id: zod.union([zod.string(), zod.null()]),
+    error: zod.union([zod.string(), zod.null()])
+  })
+});
+var CancelExtractorJobParams = zod.object({
+  id: zod.string().min(1)
+});
+var CancelExtractorJobResponse = zod.object({
+  id: zod.string(),
+  extractor_id: zod.string(),
+  extractor_version: zod.number(),
+  extractor_name: zod.string(),
+  status: zod.string(),
+  scope: zod.record(zod.string(), zod.unknown()),
+  created_at: zod.string().datetime({}),
+  started_at: zod.union([zod.string().datetime({}), zod.null()]),
+  completed_at: zod.union([zod.string(), zod.null()]),
+  processing_duration_ms: zod.union([zod.number(), zod.null()]),
+  extract_id: zod.union([zod.string(), zod.null()]),
+  error: zod.union([zod.string(), zod.null()])
+});
+var CreateExtractorBody = zod.object({
+  name: zod.string().min(1),
+  schema: zod.record(zod.string(), zod.unknown())
+});
+var CreateExtractorResponse = zod.object({
+  id: zod.string(),
+  name: zod.string(),
+  version: zod.number(),
+  schema: zod.record(zod.string(), zod.unknown()),
+  created_at: zod.string().datetime({})
+});
+var listExtractorsQueryCountDefault = 50;
+var listExtractorsQueryCountMax = 100;
+var listExtractorsQueryOffsetDefault = 0;
+var listExtractorsQueryOffsetMin = 0;
+var listExtractorsQuerySortByDefault = `created_at`;
+var listExtractorsQuerySortOrderDefault = `desc`;
+var ListExtractorsQueryParams = zod.object({
+  count: zod.number().min(1).max(listExtractorsQueryCountMax).default(listExtractorsQueryCountDefault),
+  offset: zod.number().min(listExtractorsQueryOffsetMin).default(listExtractorsQueryOffsetDefault),
+  sort_by: zod.enum(["created_at", "name", "version"]).default(listExtractorsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listExtractorsQuerySortOrderDefault),
+  name: zod.string().optional()
+});
+var ListExtractorsResponseItem = zod.object({
+  id: zod.string(),
+  name: zod.string(),
+  version: zod.number(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListExtractorsResponse = zod.array(ListExtractorsResponseItem);
+var GetExtractorParams = zod.object({
+  id: zod.string().min(1)
+});
+var GetExtractorResponse = zod.object({
+  data: zod.object({
+    id: zod.string(),
+    name: zod.string(),
+    version: zod.number(),
+    schema: zod.record(zod.string(), zod.unknown()),
+    created_at: zod.string().datetime({}),
+    updated_at: zod.string().datetime({})
+  })
+});
+var UpdateExtractorParams = zod.object({
+  id: zod.string().min(1)
+});
+var UpdateExtractorBody = zod.object({
+  schema: zod.record(zod.string(), zod.unknown())
+});
+var UpdateExtractorResponse = zod.object({
+  id: zod.string(),
+  name: zod.string(),
+  version: zod.number(),
+  schema: zod.record(zod.string(), zod.unknown()),
+  created_at: zod.string().datetime({})
+});
+var getExtractPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var GetExtractParams = zod.object({
+  id: zod.string().uuid().regex(getExtractPathIdRegExp)
+});
+var GetExtractResponse = zod.object({
+  id: zod.string(),
+  extractor_id: zod.string(),
+  extractor_version: zod.number(),
+  job_id: zod.string(),
+  scope: zod.record(zod.string(), zod.unknown()),
+  result: zod.unknown(),
+  created_at: zod.string().datetime({})
+});
+var listExtractsQueryCountDefault = 50;
+var listExtractsQueryCountMax = 100;
+var listExtractsQueryOffsetDefault = 0;
+var listExtractsQueryOffsetMin = 0;
+var listExtractsQuerySortByDefault = `created_at`;
+var listExtractsQuerySortOrderDefault = `desc`;
+var listExtractsQueryJobIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var listExtractsQueryExtractorIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var ListExtractsQueryParams = zod.object({
+  count: zod.number().min(1).max(listExtractsQueryCountMax).default(listExtractsQueryCountDefault),
+  offset: zod.number().min(listExtractsQueryOffsetMin).default(listExtractsQueryOffsetDefault),
+  sort_by: zod.enum(["created_at"]).default(listExtractsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listExtractsQuerySortOrderDefault),
+  job_id: zod.string().uuid().regex(listExtractsQueryJobIdRegExp).optional(),
+  extractor_id: zod.string().uuid().regex(listExtractsQueryExtractorIdRegExp).optional(),
+  created_after: zod.string().optional(),
+  created_before: zod.string().optional()
+});
+var ListExtractsResponseItem = zod.object({
+  id: zod.string(),
+  job_id: zod.string(),
+  extractor_id: zod.string(),
+  extractor_version: zod.number(),
+  extractor_name: zod.string(),
+  scope: zod.record(zod.string(), zod.unknown()),
+  result: zod.unknown(),
+  created_at: zod.string().datetime({})
+});
+var ListExtractsResponse = zod.array(ListExtractsResponseItem);
+var GetProfileResponse = zod.object({
+  id: zod.string(),
+  first_name: zod.union([zod.string(), zod.null()]),
+  last_name: zod.union([zod.string(), zod.null()]),
+  email: zod.string()
+});
+var CreateToolBody = zod.object({
+  name: zod.string().min(1),
+  code: zod.string().min(1),
+  description: zod.string().min(1),
+  api_key: zod.string().min(1).optional()
+});
+var CreateToolResponse = zod.object({
+  tool: zod.object({
+    id: zod.string(),
+    name: zod.string(),
+    schema: zod.record(zod.string(), zod.unknown()).optional(),
+    description: zod.string().optional(),
+    code: zod.string().optional(),
+    has_api_key: zod.boolean()
+  })
+});
+var listToolsQuerySortByDefault = `created_at`;
+var listToolsQuerySortOrderDefault = `desc`;
+var listToolsQueryCallAgentIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var ListToolsQueryParams = zod.object({
+  sort_by: zod.enum(["created_at", "updated_at", "name"]).default(listToolsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listToolsQuerySortOrderDefault),
+  call_agent_id: zod.string().uuid().regex(listToolsQueryCallAgentIdRegExp).optional()
+});
+var ListToolsResponse = zod.object({
+  tools: zod.array(
+    zod.object({
+      id: zod.string(),
+      name: zod.string(),
+      description: zod.string()
+    })
+  )
+});
+var executeCodePathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var ExecuteCodeParams = zod.object({
+  id: zod.string().uuid().regex(executeCodePathIdRegExp)
+});
+var executeCodeBodyParamsDefault = {};
+var ExecuteCodeBody = zod.object({
+  params: zod.record(zod.string(), zod.unknown()).default(executeCodeBodyParamsDefault)
+});
+var ExecuteCodeResponse = zod.object({
+  result: zod.string().optional(),
+  error: zod.object({
+    name: zod.string(),
+    message: zod.string()
+  }).optional(),
+  traces: zod.array(
+    zod.object({
+      text: zod.string(),
+      timestamp: zod.string()
+    })
+  )
+});
+var GetToolParams = zod.object({
+  id: zod.string().min(1)
+});
+var GetToolResponse = zod.object({
+  tool: zod.object({
+    id: zod.string(),
+    name: zod.string(),
+    description: zod.string(),
+    code: zod.string(),
+    schema: zod.record(zod.string(), zod.unknown()),
+    has_api_key: zod.boolean()
+  })
+});
+var updateToolPathIdRegExp = new RegExp(
+  "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+);
+var UpdateToolParams = zod.object({
+  id: zod.string().uuid().regex(updateToolPathIdRegExp)
+});
+var UpdateToolBody = zod.object({
+  name: zod.string().min(1).optional(),
+  api_key: zod.union([zod.string().min(1), zod.null()]).optional(),
+  code: zod.string().min(1).optional(),
+  description: zod.string().min(1).optional()
+});
+var UpdateToolResponse = zod.object({
+  tool: zod.object({
+    id: zod.string(),
+    name: zod.string(),
+    description: zod.string(),
+    schema: zod.record(zod.string(), zod.unknown()),
+    code: zod.string(),
+    has_api_key: zod.boolean()
+  })
+});
+var UploadFileBody = zod.object({
+  source_url: zod.string().url(),
+  document_name: zod.string().min(1),
+  processing_options: zod.object({
+    file_password: zod.string().optional(),
+    file_splitting_enabled: zod.boolean().optional()
+  }).optional(),
+  created_at_document: zod.string().datetime({}).optional(),
+  metadata: zod.record(zod.string(), zod.unknown()).optional()
+});
+var CreateAgentWebhookParams = zod.object({
+  id: zod.string().min(1)
+});
+var createAgentWebhookBodyNameMax = 256;
+var createAgentWebhookBodyUrlMax = 2048;
+var createAgentWebhookBodyAuthHeaderNameOneMax = 256;
+var createAgentWebhookBodyAuthHeaderValueOneMax = 2048;
+var CreateAgentWebhookBody = zod.object({
+  name: zod.string().min(1).max(createAgentWebhookBodyNameMax),
+  url: zod.string().url().max(createAgentWebhookBodyUrlMax),
+  auth_header_name: zod.union([
+    zod.string().max(createAgentWebhookBodyAuthHeaderNameOneMax),
+    zod.null()
+  ]).optional(),
+  auth_header_value: zod.union([
+    zod.string().max(createAgentWebhookBodyAuthHeaderValueOneMax),
+    zod.null()
+  ]).optional(),
+  enabled: zod.boolean().optional()
+});
+var CreateAgentWebhookResponse = zod.object({
+  id: zod.string(),
+  scope: zod.union([
+    zod.object({
+      extractor_id: zod.string()
+    }),
+    zod.object({
+      call_agent_id: zod.string()
+    }),
+    zod.object({
+      email_agent_id: zod.string()
+    })
+  ]),
+  name: zod.string(),
+  url: zod.string(),
+  auth_header_name: zod.union([zod.string(), zod.null()]),
+  has_auth: zod.boolean(),
+  enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListAgentWebhooksParams = zod.object({
+  id: zod.string().min(1)
+});
+var ListAgentWebhooksResponseItem = zod.object({
+  id: zod.string(),
+  scope: zod.union([
+    zod.object({
+      extractor_id: zod.string()
+    }),
+    zod.object({
+      call_agent_id: zod.string()
+    }),
+    zod.object({
+      email_agent_id: zod.string()
+    })
+  ]),
+  name: zod.string(),
+  url: zod.string(),
+  auth_header_name: zod.union([zod.string(), zod.null()]),
+  has_auth: zod.boolean(),
+  enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListAgentWebhooksResponse = zod.array(
+  ListAgentWebhooksResponseItem
+);
+var CreateEmailAgentWebhookParams = zod.object({
+  id: zod.string().min(1)
+});
+var createEmailAgentWebhookBodyNameMax = 256;
+var createEmailAgentWebhookBodyUrlMax = 2048;
+var createEmailAgentWebhookBodyAuthHeaderNameOneMax = 256;
+var createEmailAgentWebhookBodyAuthHeaderValueOneMax = 2048;
+var CreateEmailAgentWebhookBody = zod.object({
+  name: zod.string().min(1).max(createEmailAgentWebhookBodyNameMax),
+  url: zod.string().url().max(createEmailAgentWebhookBodyUrlMax),
+  auth_header_name: zod.union([
+    zod.string().max(createEmailAgentWebhookBodyAuthHeaderNameOneMax),
+    zod.null()
+  ]).optional(),
+  auth_header_value: zod.union([
+    zod.string().max(createEmailAgentWebhookBodyAuthHeaderValueOneMax),
+    zod.null()
+  ]).optional(),
+  enabled: zod.boolean().optional()
+});
+var CreateEmailAgentWebhookResponse = zod.object({
+  id: zod.string(),
+  scope: zod.union([
+    zod.object({
+      extractor_id: zod.string()
+    }),
+    zod.object({
+      call_agent_id: zod.string()
+    }),
+    zod.object({
+      email_agent_id: zod.string()
+    })
+  ]),
+  name: zod.string(),
+  url: zod.string(),
+  auth_header_name: zod.union([zod.string(), zod.null()]),
+  has_auth: zod.boolean(),
+  enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListEmailAgentWebhooksParams = zod.object({
+  id: zod.string().min(1)
+});
+var ListEmailAgentWebhooksResponseItem = zod.object({
+  id: zod.string(),
+  scope: zod.union([
+    zod.object({
+      extractor_id: zod.string()
+    }),
+    zod.object({
+      call_agent_id: zod.string()
+    }),
+    zod.object({
+      email_agent_id: zod.string()
+    })
+  ]),
+  name: zod.string(),
+  url: zod.string(),
+  auth_header_name: zod.union([zod.string(), zod.null()]),
+  has_auth: zod.boolean(),
+  enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListEmailAgentWebhooksResponse = zod.array(
+  ListEmailAgentWebhooksResponseItem
+);
+var CreateExtractorWebhookParams = zod.object({
+  id: zod.string().min(1)
+});
+var createExtractorWebhookBodyNameMax = 256;
+var createExtractorWebhookBodyUrlMax = 2048;
+var createExtractorWebhookBodyAuthHeaderNameOneMax = 256;
+var createExtractorWebhookBodyAuthHeaderValueOneMax = 2048;
+var CreateExtractorWebhookBody = zod.object({
+  name: zod.string().min(1).max(createExtractorWebhookBodyNameMax),
+  url: zod.string().url().max(createExtractorWebhookBodyUrlMax),
+  auth_header_name: zod.union([
+    zod.string().max(createExtractorWebhookBodyAuthHeaderNameOneMax),
+    zod.null()
+  ]).optional(),
+  auth_header_value: zod.union([
+    zod.string().max(createExtractorWebhookBodyAuthHeaderValueOneMax),
+    zod.null()
+  ]).optional(),
+  enabled: zod.boolean().optional()
+});
+var CreateExtractorWebhookResponse = zod.object({
+  id: zod.string(),
+  scope: zod.union([
+    zod.object({
+      extractor_id: zod.string()
+    }),
+    zod.object({
+      call_agent_id: zod.string()
+    }),
+    zod.object({
+      email_agent_id: zod.string()
+    })
+  ]),
+  name: zod.string(),
+  url: zod.string(),
+  auth_header_name: zod.union([zod.string(), zod.null()]),
+  has_auth: zod.boolean(),
+  enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListWebhooksParams = zod.object({
+  id: zod.string().min(1)
+});
+var ListWebhooksResponseItem = zod.object({
+  id: zod.string(),
+  scope: zod.union([
+    zod.object({
+      extractor_id: zod.string()
+    }),
+    zod.object({
+      call_agent_id: zod.string()
+    }),
+    zod.object({
+      email_agent_id: zod.string()
+    })
+  ]),
+  name: zod.string(),
+  url: zod.string(),
+  auth_header_name: zod.union([zod.string(), zod.null()]),
+  has_auth: zod.boolean(),
+  enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListWebhooksResponse = zod.array(ListWebhooksResponseItem);
+var DeleteWebhookParams = zod.object({
+  id: zod.string().min(1)
+});
+var DeleteWebhookResponse = zod.object({});
+var GetWebhookParams = zod.object({
+  id: zod.string().min(1)
+});
+var GetWebhookResponse = zod.object({
+  id: zod.string(),
+  scope: zod.union([
+    zod.object({
+      extractor_id: zod.string()
+    }),
+    zod.object({
+      call_agent_id: zod.string()
+    }),
+    zod.object({
+      email_agent_id: zod.string()
+    })
+  ]),
+  name: zod.string(),
+  url: zod.string(),
+  auth_header_name: zod.union([zod.string(), zod.null()]),
+  has_auth: zod.boolean(),
+  enabled: zod.boolean(),
+  created_at: zod.string().datetime({}),
+  updated_at: zod.string().datetime({})
+});
+var ListWebhookDeliveriesParams = zod.object({
+  id: zod.string().min(1)
+});
+var listWebhookDeliveriesQueryCountDefault = 50;
+var listWebhookDeliveriesQueryCountMax = 100;
+var listWebhookDeliveriesQueryOffsetDefault = 0;
+var listWebhookDeliveriesQueryOffsetMin = 0;
+var listWebhookDeliveriesQuerySortOrderDefault = `desc`;
+var ListWebhookDeliveriesQueryParams = zod.object({
+  count: zod.number().min(1).max(listWebhookDeliveriesQueryCountMax).default(listWebhookDeliveriesQueryCountDefault),
+  offset: zod.number().min(listWebhookDeliveriesQueryOffsetMin).default(listWebhookDeliveriesQueryOffsetDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listWebhookDeliveriesQuerySortOrderDefault)
+});
+var ListWebhookDeliveriesResponseItem = zod.object({
+  id: zod.string(),
+  webhook_id: zod.string(),
+  event_type: zod.string(),
+  event_id: zod.union([zod.string(), zod.null()]),
+  status_code: zod.union([zod.number(), zod.null()]),
+  duration_ms: zod.union([zod.number(), zod.null()]),
+  error_message: zod.union([zod.string(), zod.null()]),
+  created_at: zod.string().datetime({})
+});
+var ListWebhookDeliveriesResponse = zod.array(
+  ListWebhookDeliveriesResponseItem
+);
+var TestWebhookParams = zod.object({
+  id: zod.string().min(1)
+});
+var TestWebhookResponse = zod.object({
+  success: zod.boolean(),
+  status_code: zod.union([zod.number(), zod.null()]),
+  duration_ms: zod.number(),
+  error: zod.union([zod.string(), zod.null()])
+});
+
+// src/generated/server.ts
+var server = new McpServer({
+  name: "avallonAPIServer",
+  version: "1.0.0"
+});
+server.tool(
+  "listAgents",
+  "List agents",
+  {
+    queryParams: ListAgentsQueryParams
+  },
+  listAgentsHandler
+);
+server.tool(
+  "createAgent",
+  "Create agent",
+  {
+    bodyParams: CreateAgentBody
+  },
+  createAgentHandler
+);
+server.tool(
+  "getAgent",
+  "Get agent",
+  {
+    pathParams: GetAgentParams
+  },
+  getAgentHandler
+);
+server.tool(
+  "addToolsToAgent",
+  "Add tools to agent",
+  {
+    pathParams: AddToolsToAgentParams,
+    bodyParams: AddToolsToAgentBody
+  },
+  addToolsToAgentHandler
+);
+server.tool(
+  "deleteToolsFromAgent",
+  "Remove tools from agent",
+  {
+    pathParams: DeleteToolsFromAgentParams,
+    bodyParams: DeleteToolsFromAgentBody
+  },
+  deleteToolsFromAgentHandler
+);
+server.tool(
+  "getAgentPrompt",
+  "Get agent prompt",
+  {
+    pathParams: GetAgentPromptParams
+  },
+  getAgentPromptHandler
+);
+server.tool(
+  "updateAgentModels",
+  "Update agent models",
+  {
+    pathParams: UpdateAgentModelsParams,
+    bodyParams: UpdateAgentModelsBody
+  },
+  updateAgentModelsHandler
+);
+server.tool(
+  "updateCallControls",
+  "Update agent call controls",
+  {
+    pathParams: UpdateCallControlsParams,
+    bodyParams: UpdateCallControlsBody
+  },
+  updateCallControlsHandler
+);
+server.tool(
+  "scheduleJob",
+  "Schedule an outbound job",
+  {
+    pathParams: ScheduleJobParams,
+    bodyParams: ScheduleJobBody
+  },
+  scheduleJobHandler
+);
+server.tool(
+  "listJobs",
+  "List outbound jobs",
+  {
+    queryParams: ListJobsQueryParams
+  },
+  listJobsHandler
+);
+server.tool(
+  "cancelJob",
+  "Cancel an outbound job",
+  {
+    pathParams: CancelJobParams
+  },
+  cancelJobHandler
+);
+server.tool(
+  "listApiKeys",
+  "List API keys",
+  {
+    queryParams: ListApiKeysQueryParams
+  },
+  listApiKeysHandler
+);
+server.tool(
+  "createApiKey",
+  "Create an API key",
+  {
+    bodyParams: CreateApiKeyBody
+  },
+  createApiKeyHandler
+);
+server.tool(
+  "revokeApiKey",
+  "Revoke an API key",
+  {
+    pathParams: RevokeApiKeyParams
+  },
+  revokeApiKeyHandler
+);
+server.tool(
+  "createArtifact",
+  "Create artifact",
+  {
+    bodyParams: CreateArtifactBody
+  },
+  createArtifactHandler
+);
+server.tool(
+  "listArtifacts",
+  "List artifacts",
+  {
+    queryParams: ListArtifactsQueryParams
+  },
+  listArtifactsHandler
+);
+server.tool(
+  "getArtifact",
+  "Get artifact",
+  {
+    pathParams: GetArtifactParams
+  },
+  getArtifactHandler
+);
+server.tool(
+  "getArtifactMetadataKeys",
+  "Get artifact metadata keys",
+  {
+    queryParams: GetArtifactMetadataKeysQueryParams
+  },
+  getArtifactMetadataKeysHandler
+);
+server.tool(
+  "signUp",
+  "Sign up",
+  {
+    bodyParams: SignUpBody
+  },
+  signUpHandler
+);
+server.tool(
+  "signIn",
+  "Sign in",
+  {
+    bodyParams: SignInBody
+  },
+  signInHandler
+);
+server.tool(
+  "refreshToken",
+  "Refresh authentication token",
+  {
+    bodyParams: RefreshTokenBody
+  },
+  refreshTokenHandler
+);
+server.tool(
+  "getOAuthUrl",
+  "Get OAuth sign-in URL",
+  {
+    queryParams: GetOAuthUrlQueryParams
+  },
+  getOAuthUrlHandler
+);
+server.tool(
+  "listCalls",
+  "List calls",
+  {
+    queryParams: ListCallsQueryParams
+  },
+  listCallsHandler
+);
+server.tool(
+  "getCall",
+  "Get call",
+  {
+    pathParams: GetCallParams,
+    queryParams: GetCallQueryParams
+  },
+  getCallHandler
+);
+server.tool(
+  "getCallEvaluation",
+  "Get call evaluation",
+  {
+    pathParams: GetCallEvaluationParams
+  },
+  getCallEvaluationHandler
+);
+server.tool(
+  "getCallAnalytics",
+  "Get call analytics",
+  {
+    queryParams: GetCallAnalyticsQueryParams
+  },
+  getCallAnalyticsHandler
+);
+server.tool(
+  "createCallFeedback",
+  "Create feedback on a call message",
+  {
+    pathParams: CreateCallFeedbackParams,
+    bodyParams: CreateCallFeedbackBody
+  },
+  createCallFeedbackHandler
+);
+server.tool(
+  "listCallFeedback",
+  "List feedback for a call",
+  {
+    pathParams: ListCallFeedbackParams,
+    queryParams: ListCallFeedbackQueryParams
+  },
+  listCallFeedbackHandler
+);
+server.tool(
+  "deleteCallFeedback",
+  "Delete feedback",
+  {
+    pathParams: DeleteCallFeedbackParams
+  },
+  deleteCallFeedbackHandler
+);
+server.tool("createClaim", "Create claim", createClaimHandler);
+server.tool(
+  "listClaims",
+  "List claims",
+  {
+    queryParams: ListClaimsQueryParams
+  },
+  listClaimsHandler
+);
+server.tool(
+  "getClaimDetail",
+  "Get claim detail",
+  {
+    pathParams: GetClaimDetailParams
+  },
+  getClaimDetailHandler
+);
+server.tool(
+  "checkEmailUsernameAvailability",
+  "Check email username availability",
+  {
+    queryParams: CheckEmailUsernameAvailabilityQueryParams
+  },
+  checkEmailUsernameAvailabilityHandler
+);
+server.tool(
+  "createEmailAgent",
+  "Create email agent",
+  {
+    bodyParams: CreateEmailAgentBody
+  },
+  createEmailAgentHandler
+);
+server.tool(
+  "listEmailAgents",
+  "List email agents",
+  {
+    queryParams: ListEmailAgentsQueryParams
+  },
+  listEmailAgentsHandler
+);
+server.tool(
+  "updateEmailAgent",
+  "Update email agent",
+  {
+    pathParams: UpdateEmailAgentParams,
+    bodyParams: UpdateEmailAgentBody
+  },
+  updateEmailAgentHandler
+);
+server.tool(
+  "createEmail",
+  "Create email",
+  {
+    bodyParams: CreateEmailBody
+  },
+  createEmailHandler
+);
+server.tool(
+  "listEmails",
+  "List emails",
+  {
+    queryParams: ListEmailsQueryParams
+  },
+  listEmailsHandler
+);
+server.tool(
+  "getEmail",
+  "Get email",
+  {
+    pathParams: GetEmailParams
+  },
+  getEmailHandler
+);
+server.tool(
+  "listExtractorJobs",
+  "List extractor jobs",
+  {
+    queryParams: ListExtractorJobsQueryParams
+  },
+  listExtractorJobsHandler
+);
+server.tool(
+  "createExtractorJob",
+  "Create extractor job",
+  {
+    bodyParams: CreateExtractorJobBody
+  },
+  createExtractorJobHandler
+);
+server.tool(
+  "getExtractorJob",
+  "Get extractor job",
+  {
+    pathParams: GetExtractorJobParams
+  },
+  getExtractorJobHandler
+);
+server.tool(
+  "cancelExtractorJob",
+  "Cancel extractor job",
+  {
+    pathParams: CancelExtractorJobParams
+  },
+  cancelExtractorJobHandler
+);
+server.tool(
+  "createExtractor",
+  "Create extractor",
+  {
+    bodyParams: CreateExtractorBody
+  },
+  createExtractorHandler
+);
+server.tool(
+  "listExtractors",
+  "List extractors",
+  {
+    queryParams: ListExtractorsQueryParams
+  },
+  listExtractorsHandler
+);
+server.tool(
+  "getExtractor",
+  "Get extractor",
+  {
+    pathParams: GetExtractorParams
+  },
+  getExtractorHandler
+);
+server.tool(
+  "updateExtractor",
+  "Update extractor",
+  {
+    pathParams: UpdateExtractorParams,
+    bodyParams: UpdateExtractorBody
+  },
+  updateExtractorHandler
+);
+server.tool(
+  "getExtract",
+  "Get extract",
+  {
+    pathParams: GetExtractParams
+  },
+  getExtractHandler
+);
+server.tool(
+  "listExtracts",
+  "List extracts",
+  {
+    queryParams: ListExtractsQueryParams
+  },
+  listExtractsHandler
+);
+server.tool("getProfile", "Get profile", getProfileHandler);
+server.tool(
+  "createTool",
+  "Create tool",
+  {
+    bodyParams: CreateToolBody
+  },
+  createToolHandler
+);
+server.tool(
+  "listTools",
+  "List tools",
+  {
+    queryParams: ListToolsQueryParams
+  },
+  listToolsHandler
+);
+server.tool(
+  "executeCode",
+  "Execute tool",
+  {
+    pathParams: ExecuteCodeParams,
+    bodyParams: ExecuteCodeBody
+  },
+  executeCodeHandler
+);
+server.tool(
+  "getTool",
+  "Get tool",
+  {
+    pathParams: GetToolParams
+  },
+  getToolHandler
+);
+server.tool(
+  "updateTool",
+  "Update tool",
+  {
+    pathParams: UpdateToolParams,
+    bodyParams: UpdateToolBody
+  },
+  updateToolHandler
+);
+server.tool(
+  "uploadFile",
+  "Upload a file for processing",
+  {
+    bodyParams: UploadFileBody
+  },
+  uploadFileHandler
+);
+server.tool(
+  "createAgentWebhook",
+  "Create agent webhook",
+  {
+    pathParams: CreateAgentWebhookParams,
+    bodyParams: CreateAgentWebhookBody
+  },
+  createAgentWebhookHandler
+);
+server.tool(
+  "listAgentWebhooks",
+  "List agent webhooks",
+  {
+    pathParams: ListAgentWebhooksParams
+  },
+  listAgentWebhooksHandler
+);
+server.tool(
+  "createEmailAgentWebhook",
+  "Create email agent webhook",
+  {
+    pathParams: CreateEmailAgentWebhookParams,
+    bodyParams: CreateEmailAgentWebhookBody
+  },
+  createEmailAgentWebhookHandler
+);
+server.tool(
+  "listEmailAgentWebhooks",
+  "List email agent webhooks",
+  {
+    pathParams: ListEmailAgentWebhooksParams
+  },
+  listEmailAgentWebhooksHandler
+);
+server.tool(
+  "createExtractorWebhook",
+  "Create extractor webhook",
+  {
+    pathParams: CreateExtractorWebhookParams,
+    bodyParams: CreateExtractorWebhookBody
+  },
+  createExtractorWebhookHandler
+);
+server.tool(
+  "listWebhooks",
+  "List extractor webhooks",
+  {
+    pathParams: ListWebhooksParams
+  },
+  listWebhooksHandler
+);
+server.tool(
+  "deleteWebhook",
+  "Delete webhook",
+  {
+    pathParams: DeleteWebhookParams
+  },
+  deleteWebhookHandler
+);
+server.tool(
+  "getWebhook",
+  "Get webhook",
+  {
+    pathParams: GetWebhookParams
+  },
+  getWebhookHandler
+);
+server.tool(
+  "listWebhookDeliveries",
+  "List webhook deliveries",
+  {
+    pathParams: ListWebhookDeliveriesParams,
+    queryParams: ListWebhookDeliveriesQueryParams
+  },
+  listWebhookDeliveriesHandler
+);
+server.tool(
+  "testWebhook",
+  "Test webhook",
+  {
+    pathParams: TestWebhookParams
+  },
+  testWebhookHandler
+);
+var transport = new StdioServerTransport();
+server.connect(transport).then(() => {
+  console.error("MCP server running on stdio");
+}).catch(console.error);
+//# sourceMappingURL=index.js.map