@unified-api/typescript-sdk 2.73.15 → 2.73.16

package/bin/mcp-server.js

@@ -34231,9 +34231,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0",
-    sdkVersion: "2.73.15",
-    genVersion: "2.683.1",
-    userAgent: "speakeasy-sdk/typescript 2.73.15 2.683.1 1.0 @unified-api/typescript-sdk"
+    sdkVersion: "2.73.16",
+    genVersion: "2.684.0",
+    userAgent: "speakeasy-sdk/typescript 2.73.16 2.684.0 1.0 @unified-api/typescript-sdk"
   };
 });
 
@@ -42235,6 +42235,7 @@ var init_propertyconnectionpermissions = __esm(() => {
     TaskProjectWrite: "task_project_write",
     TaskTaskRead: "task_task_read",
     TaskTaskWrite: "task_task_write",
+    TaskChangeRead: "task_change_read",
     TaskCommentRead: "task_comment_read",
     TaskCommentWrite: "task_comment_write",
     ScimUsersRead: "scim_users_read",
@@ -49081,6 +49082,70 @@ var init_storagefile = __esm(() => {
   })(StorageFile$ ||= {});
 });
 
+// src/sdk/models/shared/taskchangeitem.ts
+var TaskChangeItem$inboundSchema, TaskChangeItem$outboundSchema, TaskChangeItem$;
+var init_taskchangeitem = __esm(() => {
+  init_esm();
+  TaskChangeItem$inboundSchema = objectType({
+    field: stringType(),
+    from: stringType().optional(),
+    to: stringType().optional()
+  });
+  TaskChangeItem$outboundSchema = objectType({
+    field: stringType(),
+    from: stringType().optional(),
+    to: stringType().optional()
+  });
+  ((TaskChangeItem$) => {
+    TaskChangeItem$.inboundSchema = TaskChangeItem$inboundSchema;
+    TaskChangeItem$.outboundSchema = TaskChangeItem$outboundSchema;
+  })(TaskChangeItem$ ||= {});
+});
+
+// src/sdk/models/shared/taskchange.ts
+var TaskChange$inboundSchema, TaskChange$outboundSchema, TaskChange$;
+var init_taskchange = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_taskchangeitem();
+  TaskChange$inboundSchema = objectType({
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    id: stringType().optional(),
+    items: arrayType(TaskChangeItem$inboundSchema).optional(),
+    raw: recordType(anyType()).optional(),
+    task_id: stringType().optional(),
+    updated_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    user_id: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      created_at: "createdAt",
+      task_id: "taskId",
+      updated_at: "updatedAt",
+      user_id: "userId"
+    });
+  });
+  TaskChange$outboundSchema = objectType({
+    createdAt: dateType().transform((v2) => v2.toISOString()).optional(),
+    id: stringType().optional(),
+    items: arrayType(TaskChangeItem$outboundSchema).optional(),
+    raw: recordType(anyType()).optional(),
+    taskId: stringType().optional(),
+    updatedAt: dateType().transform((v2) => v2.toISOString()).optional(),
+    userId: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      createdAt: "created_at",
+      taskId: "task_id",
+      updatedAt: "updated_at",
+      userId: "user_id"
+    });
+  });
+  ((TaskChange$) => {
+    TaskChange$.inboundSchema = TaskChange$inboundSchema;
+    TaskChange$.outboundSchema = TaskChange$outboundSchema;
+  })(TaskChange$ ||= {});
+});
+
 // src/sdk/models/shared/taskcomment.ts
 var TaskComment$inboundSchema, TaskComment$outboundSchema, TaskComment$;
 var init_taskcomment = __esm(() => {
@@ -50195,6 +50260,7 @@ var init_webhook = __esm(() => {
     TaskProject: "task_project",
     TaskTask: "task_task",
     TaskComment: "task_comment",
+    TaskChange: "task_change",
     ScimUsers: "scim_users",
     ScimGroups: "scim_groups",
     LmsCourse: "lms_course",
@@ -50575,6 +50641,8 @@ var init_shared2 = __esm(() => {
   init_security2();
   init_storagefile();
   init_storagepermission();
+  init_taskchange();
+  init_taskchangeitem();
   init_taskcomment();
   init_taskmetadata();
   init_taskproject();
@@ -55510,6 +55578,37 @@ var init_getstoragefile = __esm(() => {
   })(GetStorageFileRequest$ ||= {});
 });
 
+// src/sdk/models/operations/gettaskchange.ts
+var GetTaskChangeRequest$inboundSchema, GetTaskChangeRequest$outboundSchema, GetTaskChangeRequest$;
+var init_gettaskchange = __esm(() => {
+  init_esm();
+  init_primitives();
+  GetTaskChangeRequest$inboundSchema = objectType({
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connection_id: "connectionId"
+    });
+  });
+  GetTaskChangeRequest$outboundSchema = objectType({
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    id: stringType(),
+    raw: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connectionId: "connection_id"
+    });
+  });
+  ((GetTaskChangeRequest$) => {
+    GetTaskChangeRequest$.inboundSchema = GetTaskChangeRequest$inboundSchema;
+    GetTaskChangeRequest$.outboundSchema = GetTaskChangeRequest$outboundSchema;
+  })(GetTaskChangeRequest$ ||= {});
+});
+
 // src/sdk/models/operations/gettaskcomment.ts
 var GetTaskCommentRequest$inboundSchema, GetTaskCommentRequest$outboundSchema, GetTaskCommentRequest$;
 var init_gettaskcomment = __esm(() => {
@@ -59870,6 +59969,53 @@ var init_liststoragefiles = __esm(() => {
   })(ListStorageFilesRequest$ ||= {});
 });
 
+// src/sdk/models/operations/listtaskchanges.ts
+var ListTaskChangesRequest$inboundSchema, ListTaskChangesRequest$outboundSchema, ListTaskChangesRequest$;
+var init_listtaskchanges = __esm(() => {
+  init_esm();
+  init_primitives();
+  ListTaskChangesRequest$inboundSchema = objectType({
+    connection_id: stringType(),
+    fields: arrayType(stringType()).optional(),
+    limit: numberType().optional(),
+    offset: numberType().optional(),
+    order: stringType().optional(),
+    query: stringType().optional(),
+    raw: stringType().optional(),
+    sort: stringType().optional(),
+    task_id: stringType().optional(),
+    updated_gte: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connection_id: "connectionId",
+      task_id: "taskId",
+      updated_gte: "updatedGte"
+    });
+  });
+  ListTaskChangesRequest$outboundSchema = objectType({
+    connectionId: stringType(),
+    fields: arrayType(stringType()).optional(),
+    limit: numberType().optional(),
+    offset: numberType().optional(),
+    order: stringType().optional(),
+    query: stringType().optional(),
+    raw: stringType().optional(),
+    sort: stringType().optional(),
+    taskId: stringType().optional(),
+    updatedGte: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      connectionId: "connection_id",
+      taskId: "task_id",
+      updatedGte: "updated_gte"
+    });
+  });
+  ((ListTaskChangesRequest$) => {
+    ListTaskChangesRequest$.inboundSchema = ListTaskChangesRequest$inboundSchema;
+    ListTaskChangesRequest$.outboundSchema = ListTaskChangesRequest$outboundSchema;
+  })(ListTaskChangesRequest$ ||= {});
+});
+
 // src/sdk/models/operations/listtaskcomments.ts
 var ListTaskCommentsRequest$inboundSchema, ListTaskCommentsRequest$outboundSchema, ListTaskCommentsRequest$;
 var init_listtaskcomments = __esm(() => {
@@ -69868,6 +70014,7 @@ var init_operations = __esm(() => {
   init_getscimgroups();
   init_getscimusers();
   init_getstoragefile();
+  init_gettaskchange();
   init_gettaskcomment();
   init_gettaskproject();
   init_gettasktask();
@@ -69961,6 +70108,7 @@ var init_operations = __esm(() => {
   init_listscimgroups();
   init_listscimusers();
   init_liststoragefiles();
+  init_listtaskchanges();
   init_listtaskcomments();
   init_listtaskprojects();
   init_listtasktasks();
@@ -118587,11 +118735,122 @@ var init_taskCreateTaskTask2 = __esm(() => {
   };
 });
 
-// src/funcs/taskGetTaskProject.ts
-function taskGetTaskProject(client, request, options) {
+// src/funcs/taskGetTaskChange.ts
+function taskGetTaskChange(client, request, options) {
   return new APIPromise($do436(client, request, options));
 }
 async function $do436(client, request, options) {
+  const parsed = safeParse(request, (value) => GetTaskChangeRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    id: encodeSimple("id", payload.id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/task/{connection_id}/change/{id}")(pathParams);
+  const query = encodeFormQuery({
+    fields: payload.fields,
+    raw: payload.raw
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getTaskChange",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, TaskChange$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_taskGetTaskChange = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/taskGetTaskChange.ts
+var args436, tool$taskGetTaskChange;
+var init_taskGetTaskChange2 = __esm(() => {
+  init_taskGetTaskChange();
+  init_operations();
+  init_tools();
+  args436 = {
+    request: GetTaskChangeRequest$inboundSchema
+  };
+  tool$taskGetTaskChange = {
+    name: "task-get-task-change",
+    description: `Retrieve a change`,
+    args: args436,
+    tool: async (client, args437, ctx) => {
+      const [result, apiCall] = await taskGetTaskChange(client, args437.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/taskGetTaskProject.ts
+function taskGetTaskProject(client, request, options) {
+  return new APIPromise($do437(client, request, options));
+}
+async function $do437(client, request, options) {
   const parsed = safeParse(request, (value) => GetTaskProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118672,20 +118931,20 @@ var init_taskGetTaskProject = __esm(() => {
 });
 
 // src/mcp-server/tools/taskGetTaskProject.ts
-var args436, tool$taskGetTaskProject;
+var args437, tool$taskGetTaskProject;
 var init_taskGetTaskProject2 = __esm(() => {
   init_taskGetTaskProject();
   init_operations();
   init_tools();
-  args436 = {
+  args437 = {
     request: GetTaskProjectRequest$inboundSchema
   };
   tool$taskGetTaskProject = {
     name: "task-get-task-project",
     description: `Retrieve a project`,
-    args: args436,
-    tool: async (client, args437, ctx) => {
-      const [result, apiCall] = await taskGetTaskProject(client, args437.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args437,
+    tool: async (client, args438, ctx) => {
+      const [result, apiCall] = await taskGetTaskProject(client, args438.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -118700,9 +118959,9 @@ var init_taskGetTaskProject2 = __esm(() => {
 
 // src/funcs/taskGetTaskTask.ts
 function taskGetTaskTask(client, request, options) {
-  return new APIPromise($do437(client, request, options));
+  return new APIPromise($do438(client, request, options));
 }
-async function $do437(client, request, options) {
+async function $do438(client, request, options) {
   const parsed = safeParse(request, (value) => GetTaskTaskRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -118783,20 +119042,20 @@ var init_taskGetTaskTask = __esm(() => {
 });
 
 // src/mcp-server/tools/taskGetTaskTask.ts
-var args437, tool$taskGetTaskTask;
+var args438, tool$taskGetTaskTask;
 var init_taskGetTaskTask2 = __esm(() => {
   init_taskGetTaskTask();
   init_operations();
   init_tools();
-  args437 = {
+  args438 = {
     request: GetTaskTaskRequest$inboundSchema
   };
   tool$taskGetTaskTask = {
     name: "task-get-task-task",
     description: `Retrieve a task`,
-    args: args437,
-    tool: async (client, args438, ctx) => {
-      const [result, apiCall] = await taskGetTaskTask(client, args438.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args438,
+    tool: async (client, args439, ctx) => {
+      const [result, apiCall] = await taskGetTaskTask(client, args439.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -118809,12 +119068,12 @@ var init_taskGetTaskTask2 = __esm(() => {
   };
 });
 
-// src/funcs/taskListTaskProjects.ts
-function taskListTaskProjects(client, request, options) {
-  return new APIPromise($do438(client, request, options));
+// src/funcs/taskListTaskChanges.ts
+function taskListTaskChanges(client, request, options) {
+  return new APIPromise($do439(client, request, options));
 }
-async function $do438(client, request, options) {
-  const parsed = safeParse(request, (value) => ListTaskProjectsRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do439(client, request, options) {
+  const parsed = safeParse(request, (value) => ListTaskChangesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -118826,17 +119085,16 @@ async function $do438(client, request, options) {
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/task/{connection_id}/project")(pathParams);
+  const path = pathToFunc("/task/{connection_id}/change")(pathParams);
   const query = encodeFormQuery({
     fields: payload.fields,
     limit: payload.limit,
     offset: payload.offset,
     order: payload.order,
-    org_id: payload.org_id,
-    parent_id: payload.parent_id,
     query: payload.query,
     raw: payload.raw,
     sort: payload.sort,
+    task_id: payload.task_id,
     updated_gte: payload.updated_gte
   });
   const headers = new Headers(compactMap({
@@ -118847,7 +119105,7 @@ async function $do438(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "listTaskProjects",
+    operationID: "listTaskChanges",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -118879,13 +119137,13 @@ async function $do438(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(200, arrayType(TaskProject$inboundSchema)), fail("4XX"), fail("5XX"))(response, req);
+  const [result] = await match(json(200, arrayType(TaskChange$inboundSchema)), fail("4XX"), fail("5XX"))(response, req);
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_taskListTaskProjects = __esm(() => {
+var init_taskListTaskChanges = __esm(() => {
   init_esm();
   init_encodings();
   init_matchers();
@@ -118898,21 +119156,21 @@ var init_taskListTaskProjects = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/taskListTaskProjects.ts
-var args438, tool$taskListTaskProjects;
-var init_taskListTaskProjects2 = __esm(() => {
-  init_taskListTaskProjects();
+// src/mcp-server/tools/taskListTaskChanges.ts
+var args439, tool$taskListTaskChanges;
+var init_taskListTaskChanges2 = __esm(() => {
+  init_taskListTaskChanges();
   init_operations();
   init_tools();
-  args438 = {
-    request: ListTaskProjectsRequest$inboundSchema
+  args439 = {
+    request: ListTaskChangesRequest$inboundSchema
   };
-  tool$taskListTaskProjects = {
-    name: "task-list-task-projects",
-    description: `List all projects`,
-    args: args438,
-    tool: async (client, args439, ctx) => {
-      const [result, apiCall] = await taskListTaskProjects(client, args439.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$taskListTaskChanges = {
+    name: "task-list-task-changes",
+    description: `List all changes`,
+    args: args439,
+    tool: async (client, args440, ctx) => {
+      const [result, apiCall] = await taskListTaskChanges(client, args440.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -118925,12 +119183,12 @@ var init_taskListTaskProjects2 = __esm(() => {
   };
 });
 
-// src/funcs/taskListTaskTasks.ts
-function taskListTaskTasks(client, request, options) {
-  return new APIPromise($do439(client, request, options));
+// src/funcs/taskListTaskProjects.ts
+function taskListTaskProjects(client, request, options) {
+  return new APIPromise($do440(client, request, options));
 }
-async function $do439(client, request, options) {
-  const parsed = safeParse(request, (value) => ListTaskTasksRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do440(client, request, options) {
+  const parsed = safeParse(request, (value) => ListTaskProjectsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -118942,20 +119200,18 @@ async function $do439(client, request, options) {
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/task/{connection_id}/task")(pathParams);
+  const path = pathToFunc("/task/{connection_id}/project")(pathParams);
   const query = encodeFormQuery({
     fields: payload.fields,
     limit: payload.limit,
     offset: payload.offset,
     order: payload.order,
+    org_id: payload.org_id,
     parent_id: payload.parent_id,
-    project_id: payload.project_id,
     query: payload.query,
     raw: payload.raw,
     sort: payload.sort,
-    status: payload.status,
-    updated_gte: payload.updated_gte,
-    user_id: payload.user_id
+    updated_gte: payload.updated_gte
   });
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -118965,7 +119221,125 @@ async function $do439(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "listTaskTasks",
+    operationID: "listTaskProjects",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, arrayType(TaskProject$inboundSchema)), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_taskListTaskProjects = __esm(() => {
+  init_esm();
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_shared2();
+  init_async();
+});
+
+// src/mcp-server/tools/taskListTaskProjects.ts
+var args440, tool$taskListTaskProjects;
+var init_taskListTaskProjects2 = __esm(() => {
+  init_taskListTaskProjects();
+  init_operations();
+  init_tools();
+  args440 = {
+    request: ListTaskProjectsRequest$inboundSchema
+  };
+  tool$taskListTaskProjects = {
+    name: "task-list-task-projects",
+    description: `List all projects`,
+    args: args440,
+    tool: async (client, args441, ctx) => {
+      const [result, apiCall] = await taskListTaskProjects(client, args441.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/taskListTaskTasks.ts
+function taskListTaskTasks(client, request, options) {
+  return new APIPromise($do441(client, request, options));
+}
+async function $do441(client, request, options) {
+  const parsed = safeParse(request, (value) => ListTaskTasksRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    connection_id: encodeSimple("connection_id", payload.connection_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/task/{connection_id}/task")(pathParams);
+  const query = encodeFormQuery({
+    fields: payload.fields,
+    limit: payload.limit,
+    offset: payload.offset,
+    order: payload.order,
+    parent_id: payload.parent_id,
+    project_id: payload.project_id,
+    query: payload.query,
+    raw: payload.raw,
+    sort: payload.sort,
+    status: payload.status,
+    updated_gte: payload.updated_gte,
+    user_id: payload.user_id
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json"
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listTaskTasks",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -119017,20 +119391,20 @@ var init_taskListTaskTasks = __esm(() => {
 });
 
 // src/mcp-server/tools/taskListTaskTasks.ts
-var args439, tool$taskListTaskTasks;
+var args441, tool$taskListTaskTasks;
 var init_taskListTaskTasks2 = __esm(() => {
   init_taskListTaskTasks();
   init_operations();
   init_tools();
-  args439 = {
+  args441 = {
     request: ListTaskTasksRequest$inboundSchema
   };
   tool$taskListTaskTasks = {
     name: "task-list-task-tasks",
     description: `List all tasks`,
-    args: args439,
-    tool: async (client, args440, ctx) => {
-      const [result, apiCall] = await taskListTaskTasks(client, args440.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args441,
+    tool: async (client, args442, ctx) => {
+      const [result, apiCall] = await taskListTaskTasks(client, args442.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119045,9 +119419,9 @@ var init_taskListTaskTasks2 = __esm(() => {
 
 // src/funcs/taskPatchTaskProject.ts
 function taskPatchTaskProject(client, request, options) {
-  return new APIPromise($do440(client, request, options));
+  return new APIPromise($do442(client, request, options));
 }
-async function $do440(client, request, options) {
+async function $do442(client, request, options) {
   const parsed = safeParse(request, (value) => PatchTaskProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119129,20 +119503,20 @@ var init_taskPatchTaskProject = __esm(() => {
 });
 
 // src/mcp-server/tools/taskPatchTaskProject.ts
-var args440, tool$taskPatchTaskProject;
+var args442, tool$taskPatchTaskProject;
 var init_taskPatchTaskProject2 = __esm(() => {
   init_taskPatchTaskProject();
   init_operations();
   init_tools();
-  args440 = {
+  args442 = {
     request: PatchTaskProjectRequest$inboundSchema
   };
   tool$taskPatchTaskProject = {
     name: "task-patch-task-project",
     description: `Update a project`,
-    args: args440,
-    tool: async (client, args441, ctx) => {
-      const [result, apiCall] = await taskPatchTaskProject(client, args441.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args442,
+    tool: async (client, args443, ctx) => {
+      const [result, apiCall] = await taskPatchTaskProject(client, args443.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119157,9 +119531,9 @@ var init_taskPatchTaskProject2 = __esm(() => {
 
 // src/funcs/taskPatchTaskTask.ts
 function taskPatchTaskTask(client, request, options) {
-  return new APIPromise($do441(client, request, options));
+  return new APIPromise($do443(client, request, options));
 }
-async function $do441(client, request, options) {
+async function $do443(client, request, options) {
   const parsed = safeParse(request, (value) => PatchTaskTaskRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119241,20 +119615,20 @@ var init_taskPatchTaskTask = __esm(() => {
 });
 
 // src/mcp-server/tools/taskPatchTaskTask.ts
-var args441, tool$taskPatchTaskTask;
+var args443, tool$taskPatchTaskTask;
 var init_taskPatchTaskTask2 = __esm(() => {
   init_taskPatchTaskTask();
   init_operations();
   init_tools();
-  args441 = {
+  args443 = {
     request: PatchTaskTaskRequest$inboundSchema
   };
   tool$taskPatchTaskTask = {
     name: "task-patch-task-task",
     description: `Update a task`,
-    args: args441,
-    tool: async (client, args442, ctx) => {
-      const [result, apiCall] = await taskPatchTaskTask(client, args442.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args443,
+    tool: async (client, args444, ctx) => {
+      const [result, apiCall] = await taskPatchTaskTask(client, args444.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119269,9 +119643,9 @@ var init_taskPatchTaskTask2 = __esm(() => {
 
 // src/funcs/taskRemoveTaskProject.ts
 function taskRemoveTaskProject(client, request, options) {
-  return new APIPromise($do442(client, request, options));
+  return new APIPromise($do444(client, request, options));
 }
-async function $do442(client, request, options) {
+async function $do444(client, request, options) {
   const parsed = safeParse(request, (value) => RemoveTaskProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119349,20 +119723,20 @@ var init_taskRemoveTaskProject = __esm(() => {
 });
 
 // src/mcp-server/tools/taskRemoveTaskProject.ts
-var args442, tool$taskRemoveTaskProject;
+var args444, tool$taskRemoveTaskProject;
 var init_taskRemoveTaskProject2 = __esm(() => {
   init_taskRemoveTaskProject();
   init_operations();
   init_tools();
-  args442 = {
+  args444 = {
     request: RemoveTaskProjectRequest$inboundSchema
   };
   tool$taskRemoveTaskProject = {
     name: "task-remove-task-project",
     description: `Remove a project`,
-    args: args442,
-    tool: async (client, args443, ctx) => {
-      const [result, apiCall] = await taskRemoveTaskProject(client, args443.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args444,
+    tool: async (client, args445, ctx) => {
+      const [result, apiCall] = await taskRemoveTaskProject(client, args445.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119376,9 +119750,9 @@ var init_taskRemoveTaskProject2 = __esm(() => {
 
 // src/funcs/taskRemoveTaskTask.ts
 function taskRemoveTaskTask(client, request, options) {
-  return new APIPromise($do443(client, request, options));
+  return new APIPromise($do445(client, request, options));
 }
-async function $do443(client, request, options) {
+async function $do445(client, request, options) {
   const parsed = safeParse(request, (value) => RemoveTaskTaskRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119456,20 +119830,20 @@ var init_taskRemoveTaskTask = __esm(() => {
 });
 
 // src/mcp-server/tools/taskRemoveTaskTask.ts
-var args443, tool$taskRemoveTaskTask;
+var args445, tool$taskRemoveTaskTask;
 var init_taskRemoveTaskTask2 = __esm(() => {
   init_taskRemoveTaskTask();
   init_operations();
   init_tools();
-  args443 = {
+  args445 = {
     request: RemoveTaskTaskRequest$inboundSchema
   };
   tool$taskRemoveTaskTask = {
     name: "task-remove-task-task",
     description: `Remove a task`,
-    args: args443,
-    tool: async (client, args444, ctx) => {
-      const [result, apiCall] = await taskRemoveTaskTask(client, args444.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args445,
+    tool: async (client, args446, ctx) => {
+      const [result, apiCall] = await taskRemoveTaskTask(client, args446.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119483,9 +119857,9 @@ var init_taskRemoveTaskTask2 = __esm(() => {
 
 // src/funcs/taskUpdateTaskProject.ts
 function taskUpdateTaskProject(client, request, options) {
-  return new APIPromise($do444(client, request, options));
+  return new APIPromise($do446(client, request, options));
 }
-async function $do444(client, request, options) {
+async function $do446(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTaskProjectRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119567,20 +119941,20 @@ var init_taskUpdateTaskProject = __esm(() => {
 });
 
 // src/mcp-server/tools/taskUpdateTaskProject.ts
-var args444, tool$taskUpdateTaskProject;
+var args446, tool$taskUpdateTaskProject;
 var init_taskUpdateTaskProject2 = __esm(() => {
   init_taskUpdateTaskProject();
   init_operations();
   init_tools();
-  args444 = {
+  args446 = {
     request: UpdateTaskProjectRequest$inboundSchema
   };
   tool$taskUpdateTaskProject = {
     name: "task-update-task-project",
     description: `Update a project`,
-    args: args444,
-    tool: async (client, args445, ctx) => {
-      const [result, apiCall] = await taskUpdateTaskProject(client, args445.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args446,
+    tool: async (client, args447, ctx) => {
+      const [result, apiCall] = await taskUpdateTaskProject(client, args447.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119595,9 +119969,9 @@ var init_taskUpdateTaskProject2 = __esm(() => {
 
 // src/funcs/taskUpdateTaskTask.ts
 function taskUpdateTaskTask(client, request, options) {
-  return new APIPromise($do445(client, request, options));
+  return new APIPromise($do447(client, request, options));
 }
-async function $do445(client, request, options) {
+async function $do447(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTaskTaskRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119679,20 +120053,20 @@ var init_taskUpdateTaskTask = __esm(() => {
 });
 
 // src/mcp-server/tools/taskUpdateTaskTask.ts
-var args445, tool$taskUpdateTaskTask;
+var args447, tool$taskUpdateTaskTask;
 var init_taskUpdateTaskTask2 = __esm(() => {
   init_taskUpdateTaskTask();
   init_operations();
   init_tools();
-  args445 = {
+  args447 = {
     request: UpdateTaskTaskRequest$inboundSchema
   };
   tool$taskUpdateTaskTask = {
     name: "task-update-task-task",
     description: `Update a task`,
-    args: args445,
-    tool: async (client, args446, ctx) => {
-      const [result, apiCall] = await taskUpdateTaskTask(client, args446.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args447,
+    tool: async (client, args448, ctx) => {
+      const [result, apiCall] = await taskUpdateTaskTask(client, args448.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119707,9 +120081,9 @@ var init_taskUpdateTaskTask2 = __esm(() => {
 
 // src/funcs/ticketingCreateTicketingCustomer.ts
 function ticketingCreateTicketingCustomer(client, request, options) {
-  return new APIPromise($do446(client, request, options));
+  return new APIPromise($do448(client, request, options));
 }
-async function $do446(client, request, options) {
+async function $do448(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTicketingCustomerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119787,20 +120161,20 @@ var init_ticketingCreateTicketingCustomer = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingCreateTicketingCustomer.ts
-var args446, tool$ticketingCreateTicketingCustomer;
+var args448, tool$ticketingCreateTicketingCustomer;
 var init_ticketingCreateTicketingCustomer2 = __esm(() => {
   init_ticketingCreateTicketingCustomer();
   init_operations();
   init_tools();
-  args446 = {
+  args448 = {
     request: CreateTicketingCustomerRequest$inboundSchema
   };
   tool$ticketingCreateTicketingCustomer = {
     name: "ticketing-create-ticketing-customer",
     description: `Create a customer`,
-    args: args446,
-    tool: async (client, args447, ctx) => {
-      const [result, apiCall] = await ticketingCreateTicketingCustomer(client, args447.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args448,
+    tool: async (client, args449, ctx) => {
+      const [result, apiCall] = await ticketingCreateTicketingCustomer(client, args449.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119815,9 +120189,9 @@ var init_ticketingCreateTicketingCustomer2 = __esm(() => {
 
 // src/funcs/ticketingCreateTicketingNote.ts
 function ticketingCreateTicketingNote(client, request, options) {
-  return new APIPromise($do447(client, request, options));
+  return new APIPromise($do449(client, request, options));
 }
-async function $do447(client, request, options) {
+async function $do449(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTicketingNoteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -119895,20 +120269,20 @@ var init_ticketingCreateTicketingNote = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingCreateTicketingNote.ts
-var args447, tool$ticketingCreateTicketingNote;
+var args449, tool$ticketingCreateTicketingNote;
 var init_ticketingCreateTicketingNote2 = __esm(() => {
   init_ticketingCreateTicketingNote();
   init_operations();
   init_tools();
-  args447 = {
+  args449 = {
     request: CreateTicketingNoteRequest$inboundSchema
   };
   tool$ticketingCreateTicketingNote = {
     name: "ticketing-create-ticketing-note",
     description: `Create a note`,
-    args: args447,
-    tool: async (client, args448, ctx) => {
-      const [result, apiCall] = await ticketingCreateTicketingNote(client, args448.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args449,
+    tool: async (client, args450, ctx) => {
+      const [result, apiCall] = await ticketingCreateTicketingNote(client, args450.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -119923,9 +120297,9 @@ var init_ticketingCreateTicketingNote2 = __esm(() => {
 
 // src/funcs/ticketingCreateTicketingTicket.ts
 function ticketingCreateTicketingTicket(client, request, options) {
-  return new APIPromise($do448(client, request, options));
+  return new APIPromise($do450(client, request, options));
 }
-async function $do448(client, request, options) {
+async function $do450(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTicketingTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120003,20 +120377,20 @@ var init_ticketingCreateTicketingTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingCreateTicketingTicket.ts
-var args448, tool$ticketingCreateTicketingTicket;
+var args450, tool$ticketingCreateTicketingTicket;
 var init_ticketingCreateTicketingTicket2 = __esm(() => {
   init_ticketingCreateTicketingTicket();
   init_operations();
   init_tools();
-  args448 = {
+  args450 = {
     request: CreateTicketingTicketRequest$inboundSchema
   };
   tool$ticketingCreateTicketingTicket = {
     name: "ticketing-create-ticketing-ticket",
     description: `Create a ticket`,
-    args: args448,
-    tool: async (client, args449, ctx) => {
-      const [result, apiCall] = await ticketingCreateTicketingTicket(client, args449.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args450,
+    tool: async (client, args451, ctx) => {
+      const [result, apiCall] = await ticketingCreateTicketingTicket(client, args451.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120031,9 +120405,9 @@ var init_ticketingCreateTicketingTicket2 = __esm(() => {
 
 // src/funcs/ticketingGetTicketingCustomer.ts
 function ticketingGetTicketingCustomer(client, request, options) {
-  return new APIPromise($do449(client, request, options));
+  return new APIPromise($do451(client, request, options));
 }
-async function $do449(client, request, options) {
+async function $do451(client, request, options) {
   const parsed = safeParse(request, (value) => GetTicketingCustomerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120114,20 +120488,20 @@ var init_ticketingGetTicketingCustomer = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingGetTicketingCustomer.ts
-var args449, tool$ticketingGetTicketingCustomer;
+var args451, tool$ticketingGetTicketingCustomer;
 var init_ticketingGetTicketingCustomer2 = __esm(() => {
   init_ticketingGetTicketingCustomer();
   init_operations();
   init_tools();
-  args449 = {
+  args451 = {
     request: GetTicketingCustomerRequest$inboundSchema
   };
   tool$ticketingGetTicketingCustomer = {
     name: "ticketing-get-ticketing-customer",
     description: `Retrieve a customer`,
-    args: args449,
-    tool: async (client, args450, ctx) => {
-      const [result, apiCall] = await ticketingGetTicketingCustomer(client, args450.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args451,
+    tool: async (client, args452, ctx) => {
+      const [result, apiCall] = await ticketingGetTicketingCustomer(client, args452.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120142,9 +120516,9 @@ var init_ticketingGetTicketingCustomer2 = __esm(() => {
 
 // src/funcs/ticketingGetTicketingNote.ts
 function ticketingGetTicketingNote(client, request, options) {
-  return new APIPromise($do450(client, request, options));
+  return new APIPromise($do452(client, request, options));
 }
-async function $do450(client, request, options) {
+async function $do452(client, request, options) {
   const parsed = safeParse(request, (value) => GetTicketingNoteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120225,20 +120599,20 @@ var init_ticketingGetTicketingNote = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingGetTicketingNote.ts
-var args450, tool$ticketingGetTicketingNote;
+var args452, tool$ticketingGetTicketingNote;
 var init_ticketingGetTicketingNote2 = __esm(() => {
   init_ticketingGetTicketingNote();
   init_operations();
   init_tools();
-  args450 = {
+  args452 = {
     request: GetTicketingNoteRequest$inboundSchema
   };
   tool$ticketingGetTicketingNote = {
     name: "ticketing-get-ticketing-note",
     description: `Retrieve a note`,
-    args: args450,
-    tool: async (client, args451, ctx) => {
-      const [result, apiCall] = await ticketingGetTicketingNote(client, args451.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args452,
+    tool: async (client, args453, ctx) => {
+      const [result, apiCall] = await ticketingGetTicketingNote(client, args453.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120253,9 +120627,9 @@ var init_ticketingGetTicketingNote2 = __esm(() => {
 
 // src/funcs/ticketingGetTicketingTicket.ts
 function ticketingGetTicketingTicket(client, request, options) {
-  return new APIPromise($do451(client, request, options));
+  return new APIPromise($do453(client, request, options));
 }
-async function $do451(client, request, options) {
+async function $do453(client, request, options) {
   const parsed = safeParse(request, (value) => GetTicketingTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120336,20 +120710,20 @@ var init_ticketingGetTicketingTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingGetTicketingTicket.ts
-var args451, tool$ticketingGetTicketingTicket;
+var args453, tool$ticketingGetTicketingTicket;
 var init_ticketingGetTicketingTicket2 = __esm(() => {
   init_ticketingGetTicketingTicket();
   init_operations();
   init_tools();
-  args451 = {
+  args453 = {
     request: GetTicketingTicketRequest$inboundSchema
   };
   tool$ticketingGetTicketingTicket = {
     name: "ticketing-get-ticketing-ticket",
     description: `Retrieve a ticket`,
-    args: args451,
-    tool: async (client, args452, ctx) => {
-      const [result, apiCall] = await ticketingGetTicketingTicket(client, args452.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args453,
+    tool: async (client, args454, ctx) => {
+      const [result, apiCall] = await ticketingGetTicketingTicket(client, args454.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120364,9 +120738,9 @@ var init_ticketingGetTicketingTicket2 = __esm(() => {
 
 // src/funcs/ticketingListTicketingCustomers.ts
 function ticketingListTicketingCustomers(client, request, options) {
-  return new APIPromise($do452(client, request, options));
+  return new APIPromise($do454(client, request, options));
 }
-async function $do452(client, request, options) {
+async function $do454(client, request, options) {
   const parsed = safeParse(request, (value) => ListTicketingCustomersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120450,20 +120824,20 @@ var init_ticketingListTicketingCustomers = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingListTicketingCustomers.ts
-var args452, tool$ticketingListTicketingCustomers;
+var args454, tool$ticketingListTicketingCustomers;
 var init_ticketingListTicketingCustomers2 = __esm(() => {
   init_ticketingListTicketingCustomers();
   init_operations();
   init_tools();
-  args452 = {
+  args454 = {
     request: ListTicketingCustomersRequest$inboundSchema
   };
   tool$ticketingListTicketingCustomers = {
     name: "ticketing-list-ticketing-customers",
     description: `List all customers`,
-    args: args452,
-    tool: async (client, args453, ctx) => {
-      const [result, apiCall] = await ticketingListTicketingCustomers(client, args453.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args454,
+    tool: async (client, args455, ctx) => {
+      const [result, apiCall] = await ticketingListTicketingCustomers(client, args455.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120478,9 +120852,9 @@ var init_ticketingListTicketingCustomers2 = __esm(() => {
 
 // src/funcs/ticketingListTicketingNotes.ts
 function ticketingListTicketingNotes(client, request, options) {
-  return new APIPromise($do453(client, request, options));
+  return new APIPromise($do455(client, request, options));
 }
-async function $do453(client, request, options) {
+async function $do455(client, request, options) {
   const parsed = safeParse(request, (value) => ListTicketingNotesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120566,20 +120940,20 @@ var init_ticketingListTicketingNotes = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingListTicketingNotes.ts
-var args453, tool$ticketingListTicketingNotes;
+var args455, tool$ticketingListTicketingNotes;
 var init_ticketingListTicketingNotes2 = __esm(() => {
   init_ticketingListTicketingNotes();
   init_operations();
   init_tools();
-  args453 = {
+  args455 = {
     request: ListTicketingNotesRequest$inboundSchema
   };
   tool$ticketingListTicketingNotes = {
     name: "ticketing-list-ticketing-notes",
     description: `List all notes`,
-    args: args453,
-    tool: async (client, args454, ctx) => {
-      const [result, apiCall] = await ticketingListTicketingNotes(client, args454.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args455,
+    tool: async (client, args456, ctx) => {
+      const [result, apiCall] = await ticketingListTicketingNotes(client, args456.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120594,9 +120968,9 @@ var init_ticketingListTicketingNotes2 = __esm(() => {
 
 // src/funcs/ticketingListTicketingTickets.ts
 function ticketingListTicketingTickets(client, request, options) {
-  return new APIPromise($do454(client, request, options));
+  return new APIPromise($do456(client, request, options));
 }
-async function $do454(client, request, options) {
+async function $do456(client, request, options) {
   const parsed = safeParse(request, (value) => ListTicketingTicketsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120682,20 +121056,20 @@ var init_ticketingListTicketingTickets = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingListTicketingTickets.ts
-var args454, tool$ticketingListTicketingTickets;
+var args456, tool$ticketingListTicketingTickets;
 var init_ticketingListTicketingTickets2 = __esm(() => {
   init_ticketingListTicketingTickets();
   init_operations();
   init_tools();
-  args454 = {
+  args456 = {
     request: ListTicketingTicketsRequest$inboundSchema
   };
   tool$ticketingListTicketingTickets = {
     name: "ticketing-list-ticketing-tickets",
     description: `List all tickets`,
-    args: args454,
-    tool: async (client, args455, ctx) => {
-      const [result, apiCall] = await ticketingListTicketingTickets(client, args455.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args456,
+    tool: async (client, args457, ctx) => {
+      const [result, apiCall] = await ticketingListTicketingTickets(client, args457.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120710,9 +121084,9 @@ var init_ticketingListTicketingTickets2 = __esm(() => {
 
 // src/funcs/ticketingPatchTicketingCustomer.ts
 function ticketingPatchTicketingCustomer(client, request, options) {
-  return new APIPromise($do455(client, request, options));
+  return new APIPromise($do457(client, request, options));
 }
-async function $do455(client, request, options) {
+async function $do457(client, request, options) {
   const parsed = safeParse(request, (value) => PatchTicketingCustomerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120794,20 +121168,20 @@ var init_ticketingPatchTicketingCustomer = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingPatchTicketingCustomer.ts
-var args455, tool$ticketingPatchTicketingCustomer;
+var args457, tool$ticketingPatchTicketingCustomer;
 var init_ticketingPatchTicketingCustomer2 = __esm(() => {
   init_ticketingPatchTicketingCustomer();
   init_operations();
   init_tools();
-  args455 = {
+  args457 = {
     request: PatchTicketingCustomerRequest$inboundSchema
   };
   tool$ticketingPatchTicketingCustomer = {
     name: "ticketing-patch-ticketing-customer",
     description: `Update a customer`,
-    args: args455,
-    tool: async (client, args456, ctx) => {
-      const [result, apiCall] = await ticketingPatchTicketingCustomer(client, args456.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args457,
+    tool: async (client, args458, ctx) => {
+      const [result, apiCall] = await ticketingPatchTicketingCustomer(client, args458.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120822,9 +121196,9 @@ var init_ticketingPatchTicketingCustomer2 = __esm(() => {
 
 // src/funcs/ticketingPatchTicketingNote.ts
 function ticketingPatchTicketingNote(client, request, options) {
-  return new APIPromise($do456(client, request, options));
+  return new APIPromise($do458(client, request, options));
 }
-async function $do456(client, request, options) {
+async function $do458(client, request, options) {
   const parsed = safeParse(request, (value) => PatchTicketingNoteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -120906,20 +121280,20 @@ var init_ticketingPatchTicketingNote = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingPatchTicketingNote.ts
-var args456, tool$ticketingPatchTicketingNote;
+var args458, tool$ticketingPatchTicketingNote;
 var init_ticketingPatchTicketingNote2 = __esm(() => {
   init_ticketingPatchTicketingNote();
   init_operations();
   init_tools();
-  args456 = {
+  args458 = {
     request: PatchTicketingNoteRequest$inboundSchema
   };
   tool$ticketingPatchTicketingNote = {
     name: "ticketing-patch-ticketing-note",
     description: `Update a note`,
-    args: args456,
-    tool: async (client, args457, ctx) => {
-      const [result, apiCall] = await ticketingPatchTicketingNote(client, args457.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args458,
+    tool: async (client, args459, ctx) => {
+      const [result, apiCall] = await ticketingPatchTicketingNote(client, args459.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -120934,9 +121308,9 @@ var init_ticketingPatchTicketingNote2 = __esm(() => {
 
 // src/funcs/ticketingPatchTicketingTicket.ts
 function ticketingPatchTicketingTicket(client, request, options) {
-  return new APIPromise($do457(client, request, options));
+  return new APIPromise($do459(client, request, options));
 }
-async function $do457(client, request, options) {
+async function $do459(client, request, options) {
   const parsed = safeParse(request, (value) => PatchTicketingTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121018,20 +121392,20 @@ var init_ticketingPatchTicketingTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingPatchTicketingTicket.ts
-var args457, tool$ticketingPatchTicketingTicket;
+var args459, tool$ticketingPatchTicketingTicket;
 var init_ticketingPatchTicketingTicket2 = __esm(() => {
   init_ticketingPatchTicketingTicket();
   init_operations();
   init_tools();
-  args457 = {
+  args459 = {
     request: PatchTicketingTicketRequest$inboundSchema
   };
   tool$ticketingPatchTicketingTicket = {
     name: "ticketing-patch-ticketing-ticket",
     description: `Update a ticket`,
-    args: args457,
-    tool: async (client, args458, ctx) => {
-      const [result, apiCall] = await ticketingPatchTicketingTicket(client, args458.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args459,
+    tool: async (client, args460, ctx) => {
+      const [result, apiCall] = await ticketingPatchTicketingTicket(client, args460.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121046,9 +121420,9 @@ var init_ticketingPatchTicketingTicket2 = __esm(() => {
 
 // src/funcs/ticketingRemoveTicketingCustomer.ts
 function ticketingRemoveTicketingCustomer(client, request, options) {
-  return new APIPromise($do458(client, request, options));
+  return new APIPromise($do460(client, request, options));
 }
-async function $do458(client, request, options) {
+async function $do460(client, request, options) {
   const parsed = safeParse(request, (value) => RemoveTicketingCustomerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121126,20 +121500,20 @@ var init_ticketingRemoveTicketingCustomer = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingRemoveTicketingCustomer.ts
-var args458, tool$ticketingRemoveTicketingCustomer;
+var args460, tool$ticketingRemoveTicketingCustomer;
 var init_ticketingRemoveTicketingCustomer2 = __esm(() => {
   init_ticketingRemoveTicketingCustomer();
   init_operations();
   init_tools();
-  args458 = {
+  args460 = {
     request: RemoveTicketingCustomerRequest$inboundSchema
   };
   tool$ticketingRemoveTicketingCustomer = {
     name: "ticketing-remove-ticketing-customer",
     description: `Remove a customer`,
-    args: args458,
-    tool: async (client, args459, ctx) => {
-      const [result, apiCall] = await ticketingRemoveTicketingCustomer(client, args459.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args460,
+    tool: async (client, args461, ctx) => {
+      const [result, apiCall] = await ticketingRemoveTicketingCustomer(client, args461.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121153,9 +121527,9 @@ var init_ticketingRemoveTicketingCustomer2 = __esm(() => {
 
 // src/funcs/ticketingRemoveTicketingNote.ts
 function ticketingRemoveTicketingNote(client, request, options) {
-  return new APIPromise($do459(client, request, options));
+  return new APIPromise($do461(client, request, options));
 }
-async function $do459(client, request, options) {
+async function $do461(client, request, options) {
   const parsed = safeParse(request, (value) => RemoveTicketingNoteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121233,20 +121607,20 @@ var init_ticketingRemoveTicketingNote = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingRemoveTicketingNote.ts
-var args459, tool$ticketingRemoveTicketingNote;
+var args461, tool$ticketingRemoveTicketingNote;
 var init_ticketingRemoveTicketingNote2 = __esm(() => {
   init_ticketingRemoveTicketingNote();
   init_operations();
   init_tools();
-  args459 = {
+  args461 = {
     request: RemoveTicketingNoteRequest$inboundSchema
   };
   tool$ticketingRemoveTicketingNote = {
     name: "ticketing-remove-ticketing-note",
     description: `Remove a note`,
-    args: args459,
-    tool: async (client, args460, ctx) => {
-      const [result, apiCall] = await ticketingRemoveTicketingNote(client, args460.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args461,
+    tool: async (client, args462, ctx) => {
+      const [result, apiCall] = await ticketingRemoveTicketingNote(client, args462.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121260,9 +121634,9 @@ var init_ticketingRemoveTicketingNote2 = __esm(() => {
 
 // src/funcs/ticketingRemoveTicketingTicket.ts
 function ticketingRemoveTicketingTicket(client, request, options) {
-  return new APIPromise($do460(client, request, options));
+  return new APIPromise($do462(client, request, options));
 }
-async function $do460(client, request, options) {
+async function $do462(client, request, options) {
   const parsed = safeParse(request, (value) => RemoveTicketingTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121340,20 +121714,20 @@ var init_ticketingRemoveTicketingTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingRemoveTicketingTicket.ts
-var args460, tool$ticketingRemoveTicketingTicket;
+var args462, tool$ticketingRemoveTicketingTicket;
 var init_ticketingRemoveTicketingTicket2 = __esm(() => {
   init_ticketingRemoveTicketingTicket();
   init_operations();
   init_tools();
-  args460 = {
+  args462 = {
     request: RemoveTicketingTicketRequest$inboundSchema
   };
   tool$ticketingRemoveTicketingTicket = {
     name: "ticketing-remove-ticketing-ticket",
     description: `Remove a ticket`,
-    args: args460,
-    tool: async (client, args461, ctx) => {
-      const [result, apiCall] = await ticketingRemoveTicketingTicket(client, args461.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args462,
+    tool: async (client, args463, ctx) => {
+      const [result, apiCall] = await ticketingRemoveTicketingTicket(client, args463.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121367,9 +121741,9 @@ var init_ticketingRemoveTicketingTicket2 = __esm(() => {
 
 // src/funcs/ticketingUpdateTicketingCustomer.ts
 function ticketingUpdateTicketingCustomer(client, request, options) {
-  return new APIPromise($do461(client, request, options));
+  return new APIPromise($do463(client, request, options));
 }
-async function $do461(client, request, options) {
+async function $do463(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTicketingCustomerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121451,20 +121825,20 @@ var init_ticketingUpdateTicketingCustomer = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingUpdateTicketingCustomer.ts
-var args461, tool$ticketingUpdateTicketingCustomer;
+var args463, tool$ticketingUpdateTicketingCustomer;
 var init_ticketingUpdateTicketingCustomer2 = __esm(() => {
   init_ticketingUpdateTicketingCustomer();
   init_operations();
   init_tools();
-  args461 = {
+  args463 = {
     request: UpdateTicketingCustomerRequest$inboundSchema
   };
   tool$ticketingUpdateTicketingCustomer = {
     name: "ticketing-update-ticketing-customer",
     description: `Update a customer`,
-    args: args461,
-    tool: async (client, args462, ctx) => {
-      const [result, apiCall] = await ticketingUpdateTicketingCustomer(client, args462.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args463,
+    tool: async (client, args464, ctx) => {
+      const [result, apiCall] = await ticketingUpdateTicketingCustomer(client, args464.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121479,9 +121853,9 @@ var init_ticketingUpdateTicketingCustomer2 = __esm(() => {
 
 // src/funcs/ticketingUpdateTicketingNote.ts
 function ticketingUpdateTicketingNote(client, request, options) {
-  return new APIPromise($do462(client, request, options));
+  return new APIPromise($do464(client, request, options));
 }
-async function $do462(client, request, options) {
+async function $do464(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTicketingNoteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121563,20 +121937,20 @@ var init_ticketingUpdateTicketingNote = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingUpdateTicketingNote.ts
-var args462, tool$ticketingUpdateTicketingNote;
+var args464, tool$ticketingUpdateTicketingNote;
 var init_ticketingUpdateTicketingNote2 = __esm(() => {
   init_ticketingUpdateTicketingNote();
   init_operations();
   init_tools();
-  args462 = {
+  args464 = {
     request: UpdateTicketingNoteRequest$inboundSchema
   };
   tool$ticketingUpdateTicketingNote = {
     name: "ticketing-update-ticketing-note",
     description: `Update a note`,
-    args: args462,
-    tool: async (client, args463, ctx) => {
-      const [result, apiCall] = await ticketingUpdateTicketingNote(client, args463.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args464,
+    tool: async (client, args465, ctx) => {
+      const [result, apiCall] = await ticketingUpdateTicketingNote(client, args465.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121591,9 +121965,9 @@ var init_ticketingUpdateTicketingNote2 = __esm(() => {
 
 // src/funcs/ticketingUpdateTicketingTicket.ts
 function ticketingUpdateTicketingTicket(client, request, options) {
-  return new APIPromise($do463(client, request, options));
+  return new APIPromise($do465(client, request, options));
 }
-async function $do463(client, request, options) {
+async function $do465(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTicketingTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121675,20 +122049,20 @@ var init_ticketingUpdateTicketingTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/ticketingUpdateTicketingTicket.ts
-var args463, tool$ticketingUpdateTicketingTicket;
+var args465, tool$ticketingUpdateTicketingTicket;
 var init_ticketingUpdateTicketingTicket2 = __esm(() => {
   init_ticketingUpdateTicketingTicket();
   init_operations();
   init_tools();
-  args463 = {
+  args465 = {
     request: UpdateTicketingTicketRequest$inboundSchema
   };
   tool$ticketingUpdateTicketingTicket = {
     name: "ticketing-update-ticketing-ticket",
     description: `Update a ticket`,
-    args: args463,
-    tool: async (client, args464, ctx) => {
-      const [result, apiCall] = await ticketingUpdateTicketingTicket(client, args464.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args465,
+    tool: async (client, args466, ctx) => {
+      const [result, apiCall] = await ticketingUpdateTicketingTicket(client, args466.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121703,9 +122077,9 @@ var init_ticketingUpdateTicketingTicket2 = __esm(() => {
 
 // src/funcs/ucListUcCalls.ts
 function ucListUcCalls(client, request, options) {
-  return new APIPromise($do464(client, request, options));
+  return new APIPromise($do466(client, request, options));
 }
-async function $do464(client, request, options) {
+async function $do466(client, request, options) {
   const parsed = safeParse(request, (value) => ListUcCallsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121791,20 +122165,20 @@ var init_ucListUcCalls = __esm(() => {
 });
 
 // src/mcp-server/tools/ucListUcCalls.ts
-var args464, tool$ucListUcCalls;
+var args466, tool$ucListUcCalls;
 var init_ucListUcCalls2 = __esm(() => {
   init_ucListUcCalls();
   init_operations();
   init_tools();
-  args464 = {
+  args466 = {
     request: ListUcCallsRequest$inboundSchema
   };
   tool$ucListUcCalls = {
     name: "uc-list-uc-calls",
     description: `List all calls`,
-    args: args464,
-    tool: async (client, args465, ctx) => {
-      const [result, apiCall] = await ucListUcCalls(client, args465.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args466,
+    tool: async (client, args467, ctx) => {
+      const [result, apiCall] = await ucListUcCalls(client, args467.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121819,9 +122193,9 @@ var init_ucListUcCalls2 = __esm(() => {
 
 // src/funcs/unifiedCreateUnifiedConnection.ts
 function unifiedCreateUnifiedConnection(client, request, options) {
-  return new APIPromise($do465(client, request, options));
+  return new APIPromise($do467(client, request, options));
 }
-async function $do465(client, request, options) {
+async function $do467(client, request, options) {
   const parsed = safeParse(request, (value) => Connection$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121887,12 +122261,12 @@ var init_unifiedCreateUnifiedConnection = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedCreateUnifiedConnection.ts
-var args465, tool$unifiedCreateUnifiedConnection;
+var args467, tool$unifiedCreateUnifiedConnection;
 var init_unifiedCreateUnifiedConnection2 = __esm(() => {
   init_unifiedCreateUnifiedConnection();
   init_shared2();
   init_tools();
-  args465 = {
+  args467 = {
     request: Connection$inboundSchema
   };
   tool$unifiedCreateUnifiedConnection = {
@@ -121900,9 +122274,9 @@ var init_unifiedCreateUnifiedConnection2 = __esm(() => {
     description: `Create connection
 
 Used only to import existing customer credentials; use "Authorize new connection" instead`,
-    args: args465,
-    tool: async (client, args466, ctx) => {
-      const [result, apiCall] = await unifiedCreateUnifiedConnection(client, args466.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args467,
+    tool: async (client, args468, ctx) => {
+      const [result, apiCall] = await unifiedCreateUnifiedConnection(client, args468.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -121917,9 +122291,9 @@ Used only to import existing customer credentials; use "Authorize new connection
 
 // src/funcs/unifiedCreateUnifiedWebhook.ts
 function unifiedCreateUnifiedWebhook(client, request, options) {
-  return new APIPromise($do466(client, request, options));
+  return new APIPromise($do468(client, request, options));
 }
-async function $do466(client, request, options) {
+async function $do468(client, request, options) {
   const parsed = safeParse(request, (value) => CreateUnifiedWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -121990,12 +122364,12 @@ var init_unifiedCreateUnifiedWebhook = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedCreateUnifiedWebhook.ts
-var args466, tool$unifiedCreateUnifiedWebhook;
+var args468, tool$unifiedCreateUnifiedWebhook;
 var init_unifiedCreateUnifiedWebhook2 = __esm(() => {
   init_unifiedCreateUnifiedWebhook();
   init_operations();
   init_tools();
-  args466 = {
+  args468 = {
     request: CreateUnifiedWebhookRequest$inboundSchema
   };
   tool$unifiedCreateUnifiedWebhook = {
@@ -122003,9 +122377,9 @@ var init_unifiedCreateUnifiedWebhook2 = __esm(() => {
     description: `Create webhook subscription
 
 The data payload received by your server is described at https://docs.unified.to/unified/overview. The \`interval\` field can be set as low as 1 minute for paid accounts, and 60 minutes for free accounts.`,
-    args: args466,
-    tool: async (client, args467, ctx) => {
-      const [result, apiCall] = await unifiedCreateUnifiedWebhook(client, args467.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args468,
+    tool: async (client, args469, ctx) => {
+      const [result, apiCall] = await unifiedCreateUnifiedWebhook(client, args469.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122020,9 +122394,9 @@ The data payload received by your server is described at https://docs.unified.to
 
 // src/funcs/unifiedGetUnifiedApicall.ts
 function unifiedGetUnifiedApicall(client, request, options) {
-  return new APIPromise($do467(client, request, options));
+  return new APIPromise($do469(client, request, options));
 }
-async function $do467(client, request, options) {
+async function $do469(client, request, options) {
   const parsed = safeParse(request, (value) => GetUnifiedApicallRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122094,20 +122468,20 @@ var init_unifiedGetUnifiedApicall = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedGetUnifiedApicall.ts
-var args467, tool$unifiedGetUnifiedApicall;
+var args469, tool$unifiedGetUnifiedApicall;
 var init_unifiedGetUnifiedApicall2 = __esm(() => {
   init_unifiedGetUnifiedApicall();
   init_operations();
   init_tools();
-  args467 = {
+  args469 = {
     request: GetUnifiedApicallRequest$inboundSchema
   };
   tool$unifiedGetUnifiedApicall = {
     name: "unified-get-unified-apicall",
     description: `Retrieve specific API Call by its ID`,
-    args: args467,
-    tool: async (client, args468, ctx) => {
-      const [result, apiCall] = await unifiedGetUnifiedApicall(client, args468.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args469,
+    tool: async (client, args470, ctx) => {
+      const [result, apiCall] = await unifiedGetUnifiedApicall(client, args470.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122122,9 +122496,9 @@ var init_unifiedGetUnifiedApicall2 = __esm(() => {
 
 // src/funcs/unifiedGetUnifiedConnection.ts
 function unifiedGetUnifiedConnection(client, request, options) {
-  return new APIPromise($do468(client, request, options));
+  return new APIPromise($do470(client, request, options));
 }
-async function $do468(client, request, options) {
+async function $do470(client, request, options) {
   const parsed = safeParse(request, (value) => GetUnifiedConnectionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122196,20 +122570,20 @@ var init_unifiedGetUnifiedConnection = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedGetUnifiedConnection.ts
-var args468, tool$unifiedGetUnifiedConnection;
+var args470, tool$unifiedGetUnifiedConnection;
 var init_unifiedGetUnifiedConnection2 = __esm(() => {
   init_unifiedGetUnifiedConnection();
   init_operations();
   init_tools();
-  args468 = {
+  args470 = {
     request: GetUnifiedConnectionRequest$inboundSchema
   };
   tool$unifiedGetUnifiedConnection = {
     name: "unified-get-unified-connection",
     description: `Retrieve connection`,
-    args: args468,
-    tool: async (client, args469, ctx) => {
-      const [result, apiCall] = await unifiedGetUnifiedConnection(client, args469.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args470,
+    tool: async (client, args471, ctx) => {
+      const [result, apiCall] = await unifiedGetUnifiedConnection(client, args471.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122224,9 +122598,9 @@ var init_unifiedGetUnifiedConnection2 = __esm(() => {
 
 // src/funcs/unifiedGetUnifiedIntegrationAuth.ts
 function unifiedGetUnifiedIntegrationAuth(client, request, options) {
-  return new APIPromise($do469(client, request, options));
+  return new APIPromise($do471(client, request, options));
 }
-async function $do469(client, request, options) {
+async function $do471(client, request, options) {
   const parsed = safeParse(request, (value) => GetUnifiedIntegrationAuthRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122311,12 +122685,12 @@ var init_unifiedGetUnifiedIntegrationAuth = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedGetUnifiedIntegrationAuth.ts
-var args469, tool$unifiedGetUnifiedIntegrationAuth;
+var args471, tool$unifiedGetUnifiedIntegrationAuth;
 var init_unifiedGetUnifiedIntegrationAuth2 = __esm(() => {
   init_unifiedGetUnifiedIntegrationAuth();
   init_operations();
   init_tools();
-  args469 = {
+  args471 = {
     request: GetUnifiedIntegrationAuthRequest$inboundSchema
   };
   tool$unifiedGetUnifiedIntegrationAuth = {
@@ -122324,9 +122698,9 @@ var init_unifiedGetUnifiedIntegrationAuth2 = __esm(() => {
     description: `Authorize new connection
 
 Returns an authorization URL for the specified integration.  Once a successful authorization occurs, a new connection is created.`,
-    args: args469,
-    tool: async (client, args470, ctx) => {
-      const [result, apiCall] = await unifiedGetUnifiedIntegrationAuth(client, args470.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args471,
+    tool: async (client, args472, ctx) => {
+      const [result, apiCall] = await unifiedGetUnifiedIntegrationAuth(client, args472.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122341,9 +122715,9 @@ Returns an authorization URL for the specified integration.  Once a successful a
 
 // src/funcs/unifiedGetUnifiedWebhook.ts
 function unifiedGetUnifiedWebhook(client, request, options) {
-  return new APIPromise($do470(client, request, options));
+  return new APIPromise($do472(client, request, options));
 }
-async function $do470(client, request, options) {
+async function $do472(client, request, options) {
   const parsed = safeParse(request, (value) => GetUnifiedWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122415,20 +122789,20 @@ var init_unifiedGetUnifiedWebhook = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedGetUnifiedWebhook.ts
-var args470, tool$unifiedGetUnifiedWebhook;
+var args472, tool$unifiedGetUnifiedWebhook;
 var init_unifiedGetUnifiedWebhook2 = __esm(() => {
   init_unifiedGetUnifiedWebhook();
   init_operations();
   init_tools();
-  args470 = {
+  args472 = {
     request: GetUnifiedWebhookRequest$inboundSchema
   };
   tool$unifiedGetUnifiedWebhook = {
     name: "unified-get-unified-webhook",
     description: `Retrieve webhook by its ID`,
-    args: args470,
-    tool: async (client, args471, ctx) => {
-      const [result, apiCall] = await unifiedGetUnifiedWebhook(client, args471.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args472,
+    tool: async (client, args473, ctx) => {
+      const [result, apiCall] = await unifiedGetUnifiedWebhook(client, args473.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122443,9 +122817,9 @@ var init_unifiedGetUnifiedWebhook2 = __esm(() => {
 
 // src/funcs/unifiedListUnifiedApicalls.ts
 function unifiedListUnifiedApicalls(client, request, options) {
-  return new APIPromise($do471(client, request, options));
+  return new APIPromise($do473(client, request, options));
 }
-async function $do471(client, request, options) {
+async function $do473(client, request, options) {
   const parsed = safeParse(request, (value) => ListUnifiedApicallsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122528,20 +122902,20 @@ var init_unifiedListUnifiedApicalls = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedListUnifiedApicalls.ts
-var args471, tool$unifiedListUnifiedApicalls;
+var args473, tool$unifiedListUnifiedApicalls;
 var init_unifiedListUnifiedApicalls2 = __esm(() => {
   init_unifiedListUnifiedApicalls();
   init_operations();
   init_tools();
-  args471 = {
+  args473 = {
     request: ListUnifiedApicallsRequest$inboundSchema
   };
   tool$unifiedListUnifiedApicalls = {
     name: "unified-list-unified-apicalls",
     description: `Returns API Calls`,
-    args: args471,
-    tool: async (client, args472, ctx) => {
-      const [result, apiCall] = await unifiedListUnifiedApicalls(client, args472.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args473,
+    tool: async (client, args474, ctx) => {
+      const [result, apiCall] = await unifiedListUnifiedApicalls(client, args474.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122556,9 +122930,9 @@ var init_unifiedListUnifiedApicalls2 = __esm(() => {
 
 // src/funcs/unifiedListUnifiedConnections.ts
 function unifiedListUnifiedConnections(client, request, options) {
-  return new APIPromise($do472(client, request, options));
+  return new APIPromise($do474(client, request, options));
 }
-async function $do472(client, request, options) {
+async function $do474(client, request, options) {
   const parsed = safeParse(request, (value) => ListUnifiedConnectionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122636,20 +123010,20 @@ var init_unifiedListUnifiedConnections = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedListUnifiedConnections.ts
-var args472, tool$unifiedListUnifiedConnections;
+var args474, tool$unifiedListUnifiedConnections;
 var init_unifiedListUnifiedConnections2 = __esm(() => {
   init_unifiedListUnifiedConnections();
   init_operations();
   init_tools();
-  args472 = {
+  args474 = {
     request: ListUnifiedConnectionsRequest$inboundSchema
   };
   tool$unifiedListUnifiedConnections = {
     name: "unified-list-unified-connections",
     description: `List all connections`,
-    args: args472,
-    tool: async (client, args473, ctx) => {
-      const [result, apiCall] = await unifiedListUnifiedConnections(client, args473.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args474,
+    tool: async (client, args475, ctx) => {
+      const [result, apiCall] = await unifiedListUnifiedConnections(client, args475.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122664,9 +123038,9 @@ var init_unifiedListUnifiedConnections2 = __esm(() => {
 
 // src/funcs/unifiedListUnifiedIntegrations.ts
 function unifiedListUnifiedIntegrations(client, request, options) {
-  return new APIPromise($do473(client, request, options));
+  return new APIPromise($do475(client, request, options));
 }
-async function $do473(client, request, options) {
+async function $do475(client, request, options) {
   const parsed = safeParse(request, (value) => ListUnifiedIntegrationsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122744,20 +123118,20 @@ var init_unifiedListUnifiedIntegrations = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedListUnifiedIntegrations.ts
-var args473, tool$unifiedListUnifiedIntegrations;
+var args475, tool$unifiedListUnifiedIntegrations;
 var init_unifiedListUnifiedIntegrations2 = __esm(() => {
   init_unifiedListUnifiedIntegrations();
   init_operations();
   init_tools();
-  args473 = {
+  args475 = {
     request: ListUnifiedIntegrationsRequest$inboundSchema
   };
   tool$unifiedListUnifiedIntegrations = {
     name: "unified-list-unified-integrations",
     description: `Returns all integrations`,
-    args: args473,
-    tool: async (client, args474, ctx) => {
-      const [result, apiCall] = await unifiedListUnifiedIntegrations(client, args474.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args475,
+    tool: async (client, args476, ctx) => {
+      const [result, apiCall] = await unifiedListUnifiedIntegrations(client, args476.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122772,9 +123146,9 @@ var init_unifiedListUnifiedIntegrations2 = __esm(() => {
 
 // src/funcs/unifiedListUnifiedIntegrationWorkspaces.ts
 function unifiedListUnifiedIntegrationWorkspaces(client, request, options) {
-  return new APIPromise($do474(client, request, options));
+  return new APIPromise($do476(client, request, options));
 }
-async function $do474(client, request, options) {
+async function $do476(client, request, options) {
   const parsed = safeParse(request, (value) => ListUnifiedIntegrationWorkspacesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122857,12 +123231,12 @@ var init_unifiedListUnifiedIntegrationWorkspaces = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedListUnifiedIntegrationWorkspaces.ts
-var args474, tool$unifiedListUnifiedIntegrationWorkspaces;
+var args476, tool$unifiedListUnifiedIntegrationWorkspaces;
 var init_unifiedListUnifiedIntegrationWorkspaces2 = __esm(() => {
   init_unifiedListUnifiedIntegrationWorkspaces();
   init_operations();
   init_tools();
-  args474 = {
+  args476 = {
     request: ListUnifiedIntegrationWorkspacesRequest$inboundSchema
   };
   tool$unifiedListUnifiedIntegrationWorkspaces = {
@@ -122870,9 +123244,9 @@ var init_unifiedListUnifiedIntegrationWorkspaces2 = __esm(() => {
     description: `Returns all activated integrations in a workspace
 
 No authentication required as this is to be used by front-end interface`,
-    args: args474,
-    tool: async (client, args475, ctx) => {
-      const [result, apiCall] = await unifiedListUnifiedIntegrationWorkspaces(client, args475.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args476,
+    tool: async (client, args477, ctx) => {
+      const [result, apiCall] = await unifiedListUnifiedIntegrationWorkspaces(client, args477.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122887,9 +123261,9 @@ No authentication required as this is to be used by front-end interface`,
 
 // src/funcs/unifiedListUnifiedIssues.ts
 function unifiedListUnifiedIssues(client, request, options) {
-  return new APIPromise($do475(client, request, options));
+  return new APIPromise($do477(client, request, options));
 }
-async function $do475(client, request, options) {
+async function $do477(client, request, options) {
   const parsed = safeParse(request, (value) => ListUnifiedIssuesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -122964,20 +123338,20 @@ var init_unifiedListUnifiedIssues = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedListUnifiedIssues.ts
-var args475, tool$unifiedListUnifiedIssues;
+var args477, tool$unifiedListUnifiedIssues;
 var init_unifiedListUnifiedIssues2 = __esm(() => {
   init_unifiedListUnifiedIssues();
   init_operations();
   init_tools();
-  args475 = {
+  args477 = {
     request: ListUnifiedIssuesRequest$inboundSchema
   };
   tool$unifiedListUnifiedIssues = {
     name: "unified-list-unified-issues",
     description: `List support issues`,
-    args: args475,
-    tool: async (client, args476, ctx) => {
-      const [result, apiCall] = await unifiedListUnifiedIssues(client, args476.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args477,
+    tool: async (client, args478, ctx) => {
+      const [result, apiCall] = await unifiedListUnifiedIssues(client, args478.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -122992,9 +123366,9 @@ var init_unifiedListUnifiedIssues2 = __esm(() => {
 
 // src/funcs/unifiedListUnifiedWebhooks.ts
 function unifiedListUnifiedWebhooks(client, request, options) {
-  return new APIPromise($do476(client, request, options));
+  return new APIPromise($do478(client, request, options));
 }
-async function $do476(client, request, options) {
+async function $do478(client, request, options) {
   const parsed = safeParse(request, (value) => ListUnifiedWebhooksRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123074,20 +123448,20 @@ var init_unifiedListUnifiedWebhooks = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedListUnifiedWebhooks.ts
-var args476, tool$unifiedListUnifiedWebhooks;
+var args478, tool$unifiedListUnifiedWebhooks;
 var init_unifiedListUnifiedWebhooks2 = __esm(() => {
   init_unifiedListUnifiedWebhooks();
   init_operations();
   init_tools();
-  args476 = {
+  args478 = {
     request: ListUnifiedWebhooksRequest$inboundSchema
   };
   tool$unifiedListUnifiedWebhooks = {
     name: "unified-list-unified-webhooks",
     description: `Returns all registered webhooks`,
-    args: args476,
-    tool: async (client, args477, ctx) => {
-      const [result, apiCall] = await unifiedListUnifiedWebhooks(client, args477.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args478,
+    tool: async (client, args479, ctx) => {
+      const [result, apiCall] = await unifiedListUnifiedWebhooks(client, args479.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123102,9 +123476,9 @@ var init_unifiedListUnifiedWebhooks2 = __esm(() => {
 
 // src/funcs/unifiedPatchUnifiedConnection.ts
 function unifiedPatchUnifiedConnection(client, request, options) {
-  return new APIPromise($do477(client, request, options));
+  return new APIPromise($do479(client, request, options));
 }
-async function $do477(client, request, options) {
+async function $do479(client, request, options) {
   const parsed = safeParse(request, (value) => PatchUnifiedConnectionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123177,20 +123551,20 @@ var init_unifiedPatchUnifiedConnection = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedPatchUnifiedConnection.ts
-var args477, tool$unifiedPatchUnifiedConnection;
+var args479, tool$unifiedPatchUnifiedConnection;
 var init_unifiedPatchUnifiedConnection2 = __esm(() => {
   init_unifiedPatchUnifiedConnection();
   init_operations();
   init_tools();
-  args477 = {
+  args479 = {
     request: PatchUnifiedConnectionRequest$inboundSchema
   };
   tool$unifiedPatchUnifiedConnection = {
     name: "unified-patch-unified-connection",
     description: `Update connection`,
-    args: args477,
-    tool: async (client, args478, ctx) => {
-      const [result, apiCall] = await unifiedPatchUnifiedConnection(client, args478.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args479,
+    tool: async (client, args480, ctx) => {
+      const [result, apiCall] = await unifiedPatchUnifiedConnection(client, args480.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123205,9 +123579,9 @@ var init_unifiedPatchUnifiedConnection2 = __esm(() => {
 
 // src/funcs/unifiedPatchUnifiedWebhook.ts
 function unifiedPatchUnifiedWebhook(client, request, options) {
-  return new APIPromise($do478(client, request, options));
+  return new APIPromise($do480(client, request, options));
 }
-async function $do478(client, request, options) {
+async function $do480(client, request, options) {
   const parsed = safeParse(request, (value) => PatchUnifiedWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123280,20 +123654,20 @@ var init_unifiedPatchUnifiedWebhook = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedPatchUnifiedWebhook.ts
-var args478, tool$unifiedPatchUnifiedWebhook;
+var args480, tool$unifiedPatchUnifiedWebhook;
 var init_unifiedPatchUnifiedWebhook2 = __esm(() => {
   init_unifiedPatchUnifiedWebhook();
   init_operations();
   init_tools();
-  args478 = {
+  args480 = {
     request: PatchUnifiedWebhookRequest$inboundSchema
   };
   tool$unifiedPatchUnifiedWebhook = {
     name: "unified-patch-unified-webhook",
     description: `Update webhook subscription`,
-    args: args478,
-    tool: async (client, args479, ctx) => {
-      const [result, apiCall] = await unifiedPatchUnifiedWebhook(client, args479.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args480,
+    tool: async (client, args481, ctx) => {
+      const [result, apiCall] = await unifiedPatchUnifiedWebhook(client, args481.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123308,9 +123682,9 @@ var init_unifiedPatchUnifiedWebhook2 = __esm(() => {
 
 // src/funcs/unifiedPatchUnifiedWebhookTrigger.ts
 function unifiedPatchUnifiedWebhookTrigger(client, request, options) {
-  return new APIPromise($do479(client, request, options));
+  return new APIPromise($do481(client, request, options));
 }
-async function $do479(client, request, options) {
+async function $do481(client, request, options) {
   const parsed = safeParse(request, (value) => PatchUnifiedWebhookTriggerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123384,20 +123758,20 @@ var init_unifiedPatchUnifiedWebhookTrigger = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedPatchUnifiedWebhookTrigger.ts
-var args479, tool$unifiedPatchUnifiedWebhookTrigger;
+var args481, tool$unifiedPatchUnifiedWebhookTrigger;
 var init_unifiedPatchUnifiedWebhookTrigger2 = __esm(() => {
   init_unifiedPatchUnifiedWebhookTrigger();
   init_operations();
   init_tools();
-  args479 = {
+  args481 = {
     request: PatchUnifiedWebhookTriggerRequest$inboundSchema
   };
   tool$unifiedPatchUnifiedWebhookTrigger = {
     name: "unified-patch-unified-webhook-trigger",
     description: `Trigger webhook`,
-    args: args479,
-    tool: async (client, args480, ctx) => {
-      const [result, apiCall] = await unifiedPatchUnifiedWebhookTrigger(client, args480.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args481,
+    tool: async (client, args482, ctx) => {
+      const [result, apiCall] = await unifiedPatchUnifiedWebhookTrigger(client, args482.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123411,9 +123785,9 @@ var init_unifiedPatchUnifiedWebhookTrigger2 = __esm(() => {
 
 // src/funcs/unifiedRemoveUnifiedConnection.ts
 function unifiedRemoveUnifiedConnection(client, request, options) {
-  return new APIPromise($do480(client, request, options));
+  return new APIPromise($do482(client, request, options));
 }
-async function $do480(client, request, options) {
+async function $do482(client, request, options) {
   const parsed = safeParse(request, (value) => RemoveUnifiedConnectionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123487,20 +123861,20 @@ var init_unifiedRemoveUnifiedConnection = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedRemoveUnifiedConnection.ts
-var args480, tool$unifiedRemoveUnifiedConnection;
+var args482, tool$unifiedRemoveUnifiedConnection;
 var init_unifiedRemoveUnifiedConnection2 = __esm(() => {
   init_unifiedRemoveUnifiedConnection();
   init_operations();
   init_tools();
-  args480 = {
+  args482 = {
     request: RemoveUnifiedConnectionRequest$inboundSchema
   };
   tool$unifiedRemoveUnifiedConnection = {
     name: "unified-remove-unified-connection",
     description: `Remove connection`,
-    args: args480,
-    tool: async (client, args481, ctx) => {
-      const [result, apiCall] = await unifiedRemoveUnifiedConnection(client, args481.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args482,
+    tool: async (client, args483, ctx) => {
+      const [result, apiCall] = await unifiedRemoveUnifiedConnection(client, args483.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123514,9 +123888,9 @@ var init_unifiedRemoveUnifiedConnection2 = __esm(() => {
 
 // src/funcs/unifiedRemoveUnifiedWebhook.ts
 function unifiedRemoveUnifiedWebhook(client, request, options) {
-  return new APIPromise($do481(client, request, options));
+  return new APIPromise($do483(client, request, options));
 }
-async function $do481(client, request, options) {
+async function $do483(client, request, options) {
   const parsed = safeParse(request, (value) => RemoveUnifiedWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123590,20 +123964,20 @@ var init_unifiedRemoveUnifiedWebhook = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedRemoveUnifiedWebhook.ts
-var args481, tool$unifiedRemoveUnifiedWebhook;
+var args483, tool$unifiedRemoveUnifiedWebhook;
 var init_unifiedRemoveUnifiedWebhook2 = __esm(() => {
   init_unifiedRemoveUnifiedWebhook();
   init_operations();
   init_tools();
-  args481 = {
+  args483 = {
     request: RemoveUnifiedWebhookRequest$inboundSchema
   };
   tool$unifiedRemoveUnifiedWebhook = {
     name: "unified-remove-unified-webhook",
     description: `Remove webhook subscription`,
-    args: args481,
-    tool: async (client, args482, ctx) => {
-      const [result, apiCall] = await unifiedRemoveUnifiedWebhook(client, args482.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args483,
+    tool: async (client, args484, ctx) => {
+      const [result, apiCall] = await unifiedRemoveUnifiedWebhook(client, args484.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123617,9 +123991,9 @@ var init_unifiedRemoveUnifiedWebhook2 = __esm(() => {
 
 // src/funcs/unifiedUpdateUnifiedConnection.ts
 function unifiedUpdateUnifiedConnection(client, request, options) {
-  return new APIPromise($do482(client, request, options));
+  return new APIPromise($do484(client, request, options));
 }
-async function $do482(client, request, options) {
+async function $do484(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateUnifiedConnectionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123692,20 +124066,20 @@ var init_unifiedUpdateUnifiedConnection = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedUpdateUnifiedConnection.ts
-var args482, tool$unifiedUpdateUnifiedConnection;
+var args484, tool$unifiedUpdateUnifiedConnection;
 var init_unifiedUpdateUnifiedConnection2 = __esm(() => {
   init_unifiedUpdateUnifiedConnection();
   init_operations();
   init_tools();
-  args482 = {
+  args484 = {
     request: UpdateUnifiedConnectionRequest$inboundSchema
   };
   tool$unifiedUpdateUnifiedConnection = {
     name: "unified-update-unified-connection",
     description: `Update connection`,
-    args: args482,
-    tool: async (client, args483, ctx) => {
-      const [result, apiCall] = await unifiedUpdateUnifiedConnection(client, args483.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args484,
+    tool: async (client, args485, ctx) => {
+      const [result, apiCall] = await unifiedUpdateUnifiedConnection(client, args485.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123720,9 +124094,9 @@ var init_unifiedUpdateUnifiedConnection2 = __esm(() => {
 
 // src/funcs/unifiedUpdateUnifiedWebhook.ts
 function unifiedUpdateUnifiedWebhook(client, request, options) {
-  return new APIPromise($do483(client, request, options));
+  return new APIPromise($do485(client, request, options));
 }
-async function $do483(client, request, options) {
+async function $do485(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateUnifiedWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123795,20 +124169,20 @@ var init_unifiedUpdateUnifiedWebhook = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedUpdateUnifiedWebhook.ts
-var args483, tool$unifiedUpdateUnifiedWebhook;
+var args485, tool$unifiedUpdateUnifiedWebhook;
 var init_unifiedUpdateUnifiedWebhook2 = __esm(() => {
   init_unifiedUpdateUnifiedWebhook();
   init_operations();
   init_tools();
-  args483 = {
+  args485 = {
     request: UpdateUnifiedWebhookRequest$inboundSchema
   };
   tool$unifiedUpdateUnifiedWebhook = {
     name: "unified-update-unified-webhook",
     description: `Update webhook subscription`,
-    args: args483,
-    tool: async (client, args484, ctx) => {
-      const [result, apiCall] = await unifiedUpdateUnifiedWebhook(client, args484.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args485,
+    tool: async (client, args486, ctx) => {
+      const [result, apiCall] = await unifiedUpdateUnifiedWebhook(client, args486.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123823,9 +124197,9 @@ var init_unifiedUpdateUnifiedWebhook2 = __esm(() => {
 
 // src/funcs/unifiedUpdateUnifiedWebhookTrigger.ts
 function unifiedUpdateUnifiedWebhookTrigger(client, request, options) {
-  return new APIPromise($do484(client, request, options));
+  return new APIPromise($do486(client, request, options));
 }
-async function $do484(client, request, options) {
+async function $do486(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateUnifiedWebhookTriggerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -123899,20 +124273,20 @@ var init_unifiedUpdateUnifiedWebhookTrigger = __esm(() => {
 });
 
 // src/mcp-server/tools/unifiedUpdateUnifiedWebhookTrigger.ts
-var args484, tool$unifiedUpdateUnifiedWebhookTrigger;
+var args486, tool$unifiedUpdateUnifiedWebhookTrigger;
 var init_unifiedUpdateUnifiedWebhookTrigger2 = __esm(() => {
   init_unifiedUpdateUnifiedWebhookTrigger();
   init_operations();
   init_tools();
-  args484 = {
+  args486 = {
     request: UpdateUnifiedWebhookTriggerRequest$inboundSchema
   };
   tool$unifiedUpdateUnifiedWebhookTrigger = {
     name: "unified-update-unified-webhook-trigger",
     description: `Trigger webhook`,
-    args: args484,
-    tool: async (client, args485, ctx) => {
-      const [result, apiCall] = await unifiedUpdateUnifiedWebhookTrigger(client, args485.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args486,
+    tool: async (client, args487, ctx) => {
+      const [result, apiCall] = await unifiedUpdateUnifiedWebhookTrigger(client, args487.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -123928,7 +124302,7 @@ var init_unifiedUpdateUnifiedWebhookTrigger2 = __esm(() => {
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "UnifiedTo",
-    version: "2.73.15"
+    version: "2.73.16"
   });
   const client = new UnifiedToCore({
     security: deps.security,
@@ -124376,8 +124750,10 @@ function createMCPServer(deps) {
   tool(tool$storageUpdateStorageFile);
   tool(tool$taskCreateTaskProject);
   tool(tool$taskCreateTaskTask);
+  tool(tool$taskGetTaskChange);
   tool(tool$taskGetTaskProject);
   tool(tool$taskGetTaskTask);
+  tool(tool$taskListTaskChanges);
   tool(tool$taskListTaskProjects);
   tool(tool$taskListTaskTasks);
   tool(tool$taskPatchTaskProject);
@@ -124868,8 +125244,10 @@ var init_server2 = __esm(() => {
   init_storageUpdateStorageFile2();
   init_taskCreateTaskProject2();
   init_taskCreateTaskTask2();
+  init_taskGetTaskChange2();
   init_taskGetTaskProject2();
   init_taskGetTaskTask2();
+  init_taskListTaskChanges2();
   init_taskListTaskProjects2();
   init_taskListTaskTasks2();
   init_taskPatchTaskProject2();
@@ -126091,7 +126469,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "2.73.15"
+    currentVersion: "2.73.16"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -126099,5 +126477,5 @@ export {
   app
 };
 
-//# debugId=9B20FFAC8790836464756E2164756E21
+//# debugId=C1AAFE91C429F03D64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map