@moovio/sdk 0.14.0 → 0.14.1

package/bin/mcp-server.js

@@ -34246,9 +34246,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "latest",
-    sdkVersion: "0.14.0",
-    genVersion: "2.640.2",
-    userAgent: "speakeasy-sdk/typescript 0.14.0 2.640.2 latest @moovio/sdk"
+    sdkVersion: "0.14.1",
+    genVersion: "2.648.1",
+    userAgent: "speakeasy-sdk/typescript 0.14.1 2.648.1 latest @moovio/sdk"
   };
 });
 
@@ -35245,8 +35245,14 @@ var init_apierror = __esm(() => {
       }
       const body = httpMeta.body || `""`;
       message += body.length > 100 ? `
-` : " ";
-      message += `Body ${body}`;
+` : ". ";
+      let bodyDisplay = body;
+      if (body.length > 1e4) {
+        const truncated = body.substring(0, 1e4);
+        const remaining = body.length - 1e4;
+        bodyDisplay = `${truncated}...and ${remaining} more chars`;
+      }
+      message += `Body: ${bodyDisplay}`;
       message = message.trim();
       super(message, httpMeta);
       this.name = "APIError";
@@ -41029,6 +41035,63 @@ var init_createterminalapplication = __esm(() => {
   })(CreateTerminalApplication$ ||= {});
 });
 
+// src/models/components/ticketcontact.ts
+var TicketContact$inboundSchema, TicketContact$outboundSchema, TicketContact$;
+var init_ticketcontact = __esm(() => {
+  init_esm();
+  TicketContact$inboundSchema = objectType({
+    email: stringType(),
+    name: stringType().optional()
+  });
+  TicketContact$outboundSchema = objectType({
+    email: stringType(),
+    name: stringType().optional()
+  });
+  ((TicketContact$) => {
+    TicketContact$.inboundSchema = TicketContact$inboundSchema;
+    TicketContact$.outboundSchema = TicketContact$outboundSchema;
+  })(TicketContact$ ||= {});
+});
+
+// src/models/components/createticket.ts
+var CreateTicket$inboundSchema, CreateTicket$outboundSchema, CreateTicket$;
+var init_createticket = __esm(() => {
+  init_esm();
+  init_ticketcontact();
+  CreateTicket$inboundSchema = objectType({
+    title: stringType(),
+    body: stringType(),
+    contact: TicketContact$inboundSchema
+  });
+  CreateTicket$outboundSchema = objectType({
+    title: stringType(),
+    body: stringType(),
+    contact: TicketContact$outboundSchema
+  });
+  ((CreateTicket$) => {
+    CreateTicket$.inboundSchema = CreateTicket$inboundSchema;
+    CreateTicket$.outboundSchema = CreateTicket$outboundSchema;
+  })(CreateTicket$ ||= {});
+});
+
+// src/models/components/createticketcontacterror.ts
+var CreateTicketContactError$inboundSchema, CreateTicketContactError$outboundSchema, CreateTicketContactError$;
+var init_createticketcontacterror = __esm(() => {
+  init_esm();
+  CreateTicketContactError$inboundSchema = objectType({
+    email: stringType().optional(),
+    name: stringType().optional()
+  });
+  CreateTicketContactError$outboundSchema = objectType({
+    email: stringType().optional(),
+    name: stringType().optional()
+  });
+  ((CreateTicketContactError$) => {
+    CreateTicketContactError$.inboundSchema = CreateTicketContactError$inboundSchema;
+    CreateTicketContactError$.outboundSchema = CreateTicketContactError$outboundSchema;
+  })(CreateTicketContactError$ ||= {});
+});
+
 // src/models/components/createtransferdestinationach.ts
 var CreateTransferDestinationACH$inboundSchema, CreateTransferDestinationACH$outboundSchema, CreateTransferDestinationACH$;
 var init_createtransferdestinationach = __esm(() => {
@@ -45094,6 +45157,78 @@ var init_terminalconfiguration = __esm(() => {
   })(TerminalConfiguration$ ||= {});
 });
 
+// src/models/components/ticketstatus.ts
+var TicketStatus, TicketStatus$inboundSchema, TicketStatus$outboundSchema, TicketStatus$;
+var init_ticketstatus = __esm(() => {
+  init_esm();
+  TicketStatus = {
+    New: "new",
+    InProgress: "in-progress",
+    OnHold: "on-hold",
+    Closed: "closed"
+  };
+  TicketStatus$inboundSchema = nativeEnumType(TicketStatus);
+  TicketStatus$outboundSchema = TicketStatus$inboundSchema;
+  ((TicketStatus$) => {
+    TicketStatus$.inboundSchema = TicketStatus$inboundSchema;
+    TicketStatus$.outboundSchema = TicketStatus$outboundSchema;
+  })(TicketStatus$ ||= {});
+});
+
+// src/models/components/ticket.ts
+var Ticket$inboundSchema, Ticket$outboundSchema, Ticket$;
+var init_ticket = __esm(() => {
+  init_esm();
+  init_ticketcontact();
+  init_ticketstatus();
+  Ticket$inboundSchema = objectType({
+    ticketID: stringType(),
+    number: numberType().int(),
+    title: stringType(),
+    contact: TicketContact$inboundSchema,
+    status: TicketStatus$inboundSchema,
+    createdOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    updatedOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    latestMessageOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    closedOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional()
+  });
+  Ticket$outboundSchema = objectType({
+    ticketID: stringType(),
+    number: numberType().int(),
+    title: stringType(),
+    contact: TicketContact$outboundSchema,
+    status: TicketStatus$outboundSchema,
+    createdOn: dateType().transform((v2) => v2.toISOString()),
+    updatedOn: dateType().transform((v2) => v2.toISOString()),
+    latestMessageOn: dateType().transform((v2) => v2.toISOString()).optional(),
+    closedOn: dateType().transform((v2) => v2.toISOString()).optional()
+  });
+  ((Ticket$) => {
+    Ticket$.inboundSchema = Ticket$inboundSchema;
+    Ticket$.outboundSchema = Ticket$outboundSchema;
+  })(Ticket$ ||= {});
+});
+
+// src/models/components/ticketmessage.ts
+var TicketMessage$inboundSchema, TicketMessage$outboundSchema, TicketMessage$;
+var init_ticketmessage = __esm(() => {
+  init_esm();
+  TicketMessage$inboundSchema = objectType({
+    author: stringType(),
+    body: stringType(),
+    sentOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+  });
+  TicketMessage$outboundSchema = objectType({
+    author: stringType(),
+    body: stringType(),
+    sentOn: dateType().transform((v2) => v2.toISOString())
+  });
+  ((TicketMessage$) => {
+    TicketMessage$.inboundSchema = TicketMessage$inboundSchema;
+    TicketMessage$.outboundSchema = TicketMessage$outboundSchema;
+  })(TicketMessage$ ||= {});
+});
+
 // src/models/components/transfer.ts
 var Transfer$inboundSchema, Transfer$outboundSchema, Transfer$;
 var init_transfer = __esm(() => {
@@ -45675,6 +45810,38 @@ var init_updaterepresentative = __esm(() => {
   })(UpdateRepresentative$ ||= {});
 });
 
+// src/models/components/updateticketstatus.ts
+var UpdateTicketStatus, UpdateTicketStatus$inboundSchema, UpdateTicketStatus$outboundSchema, UpdateTicketStatus$;
+var init_updateticketstatus = __esm(() => {
+  init_esm();
+  UpdateTicketStatus = {
+    Closed: "closed"
+  };
+  UpdateTicketStatus$inboundSchema = nativeEnumType(UpdateTicketStatus);
+  UpdateTicketStatus$outboundSchema = UpdateTicketStatus$inboundSchema;
+  ((UpdateTicketStatus$) => {
+    UpdateTicketStatus$.inboundSchema = UpdateTicketStatus$inboundSchema;
+    UpdateTicketStatus$.outboundSchema = UpdateTicketStatus$outboundSchema;
+  })(UpdateTicketStatus$ ||= {});
+});
+
+// src/models/components/updateticket.ts
+var UpdateTicket$inboundSchema, UpdateTicket$outboundSchema, UpdateTicket$;
+var init_updateticket = __esm(() => {
+  init_esm();
+  init_updateticketstatus();
+  UpdateTicket$inboundSchema = objectType({
+    status: UpdateTicketStatus$inboundSchema.optional()
+  });
+  UpdateTicket$outboundSchema = objectType({
+    status: UpdateTicketStatus$outboundSchema.optional()
+  });
+  ((UpdateTicket$) => {
+    UpdateTicket$.inboundSchema = UpdateTicket$inboundSchema;
+    UpdateTicket$.outboundSchema = UpdateTicket$outboundSchema;
+  })(UpdateTicket$ ||= {});
+});
+
 // src/models/components/updateunderwriting.ts
 var UpdateUnderwriting$inboundSchema, UpdateUnderwriting$outboundSchema, UpdateUnderwriting$;
 var init_updateunderwriting = __esm(() => {
@@ -46918,6 +47085,8 @@ var init_components = __esm(() => {
   init_createreversal();
   init_createsweepconfig();
   init_createterminalapplication();
+  init_createticket();
+  init_createticketcontacterror();
   init_createtransfer();
   init_createtransferdestination();
   init_createtransferdestinationach();
@@ -47145,6 +47314,10 @@ var init_components = __esm(() => {
   init_termsofserviceerror();
   init_termsofservicetoken();
   init_termsofservicetokenupdate();
+  init_ticket();
+  init_ticketcontact();
+  init_ticketmessage();
+  init_ticketstatus();
   init_tokentype();
   init_transactionsource();
   init_transfer();
@@ -47169,6 +47342,8 @@ var init_components = __esm(() => {
   init_updateissuedcard();
   init_updatepaymentlink();
   init_updaterepresentative();
+  init_updateticket();
+  init_updateticketstatus();
   init_updateunderwriting();
   init_upsertschedule();
   init_upsertunderwriting();
@@ -47687,6 +47862,52 @@ var init_createsweepconfigerror = __esm(() => {
   })(CreateSweepConfigError$ ||= {});
 });
 
+// src/models/errors/createticketerror.ts
+var CreateTicketError, CreateTicketError$inboundSchema, CreateTicketError$outboundSchema, CreateTicketError$;
+var init_createticketerror = __esm(() => {
+  init_esm();
+  init_components();
+  init_mooverror();
+  CreateTicketError = class CreateTicketError extends MoovError {
+    title;
+    contact;
+    data$;
+    constructor(err, httpMeta) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message, httpMeta);
+      this.data$ = err;
+      if (err.title != null)
+        this.title = err.title;
+      if (err.contact != null)
+        this.contact = err.contact;
+      this.name = "CreateTicketError";
+    }
+  };
+  CreateTicketError$inboundSchema = objectType({
+    title: stringType().optional(),
+    body: stringType().optional(),
+    contact: CreateTicketContactError$inboundSchema.optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new CreateTicketError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  CreateTicketError$outboundSchema = instanceOfType(CreateTicketError).transform((v2) => v2.data$).pipe(objectType({
+    title: stringType().optional(),
+    body: stringType().optional(),
+    contact: CreateTicketContactError$outboundSchema.optional()
+  }));
+  ((CreateTicketError$) => {
+    CreateTicketError$.inboundSchema = CreateTicketError$inboundSchema;
+    CreateTicketError$.outboundSchema = CreateTicketError$outboundSchema;
+  })(CreateTicketError$ ||= {});
+});
+
 // src/models/errors/feeplanagreementerror.ts
 var FeePlanAgreementError, FeePlanAgreementError$inboundSchema, FeePlanAgreementError$outboundSchema, FeePlanAgreementError$;
 var init_feeplanagreementerror = __esm(() => {
@@ -49060,6 +49281,44 @@ var init_updatepaymentlinkerror = __esm(() => {
   })(UpdatePaymentLinkError$ ||= {});
 });
 
+// src/models/errors/updateticketerror.ts
+var UpdateTicketError, UpdateTicketError$inboundSchema, UpdateTicketError$outboundSchema, UpdateTicketError$;
+var init_updateticketerror = __esm(() => {
+  init_esm();
+  init_mooverror();
+  UpdateTicketError = class UpdateTicketError extends MoovError {
+    status;
+    data$;
+    constructor(err, httpMeta) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message, httpMeta);
+      this.data$ = err;
+      if (err.status != null)
+        this.status = err.status;
+      this.name = "UpdateTicketError";
+    }
+  };
+  UpdateTicketError$inboundSchema = objectType({
+    status: stringType().optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new UpdateTicketError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  UpdateTicketError$outboundSchema = instanceOfType(UpdateTicketError).transform((v2) => v2.data$).pipe(objectType({
+    status: stringType().optional()
+  }));
+  ((UpdateTicketError$) => {
+    UpdateTicketError$.inboundSchema = UpdateTicketError$inboundSchema;
+    UpdateTicketError$.outboundSchema = UpdateTicketError$outboundSchema;
+  })(UpdateTicketError$ ||= {});
+});
+
 // src/models/errors/updateunderwritingerror.ts
 var UpdateUnderwritingError, UpdateUnderwritingErrorError$inboundSchema, UpdateUnderwritingErrorError$outboundSchema, UpdateUnderwritingErrorError$, UpdateUnderwritingError$inboundSchema, UpdateUnderwritingError$outboundSchema, UpdateUnderwritingError$;
 var init_updateunderwritingerror = __esm(() => {
@@ -49238,6 +49497,7 @@ var init_errors2 = __esm(() => {
   init_createaccount2();
   init_createpaymentlinkerror();
   init_createsweepconfigerror();
+  init_createticketerror();
   init_feeplanagreementerror();
   init_fileuploadvalidationerror();
   init_filevalidationerror();
@@ -49264,6 +49524,7 @@ var init_errors2 = __esm(() => {
   init_updatecarderror();
   init_updateissuedcarderror();
   init_updatepaymentlinkerror();
+  init_updateticketerror();
   init_updateunderwritingerror();
   init_upsertunderwritingerror();
 });
@@ -50441,6 +50702,74 @@ var init_createterminalapplication2 = __esm(() => {
   })(CreateTerminalApplicationResponse$ ||= {});
 });
 
+// src/models/operations/createticket.ts
+var CreateTicketGlobals$inboundSchema, CreateTicketGlobals$outboundSchema, CreateTicketGlobals$, CreateTicketRequest$inboundSchema, CreateTicketRequest$outboundSchema, CreateTicketRequest$, CreateTicketResponse$inboundSchema, CreateTicketResponse$outboundSchema, CreateTicketResponse$;
+var init_createticket2 = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  CreateTicketGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  CreateTicketGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((CreateTicketGlobals$) => {
+    CreateTicketGlobals$.inboundSchema = CreateTicketGlobals$inboundSchema;
+    CreateTicketGlobals$.outboundSchema = CreateTicketGlobals$outboundSchema;
+  })(CreateTicketGlobals$ ||= {});
+  CreateTicketRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    CreateTicket: CreateTicket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      CreateTicket: "createTicket"
+    });
+  });
+  CreateTicketRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    createTicket: CreateTicket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      createTicket: "CreateTicket"
+    });
+  });
+  ((CreateTicketRequest$) => {
+    CreateTicketRequest$.inboundSchema = CreateTicketRequest$inboundSchema;
+    CreateTicketRequest$.outboundSchema = CreateTicketRequest$outboundSchema;
+  })(CreateTicketRequest$ ||= {});
+  CreateTicketResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: Ticket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  CreateTicketResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Ticket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((CreateTicketResponse$) => {
+    CreateTicketResponse$.inboundSchema = CreateTicketResponse$inboundSchema;
+    CreateTicketResponse$.outboundSchema = CreateTicketResponse$outboundSchema;
+  })(CreateTicketResponse$ ||= {});
+});
+
 // src/models/operations/createtransfer.ts
 var CreateTransferGlobals$inboundSchema, CreateTransferGlobals$outboundSchema, CreateTransferGlobals$, CreateTransferRequest$inboundSchema, CreateTransferRequest$outboundSchema, CreateTransferRequest$, CreateTransferResponseResult$inboundSchema, CreateTransferResponseResult$outboundSchema, CreateTransferResponseResult$, CreateTransferResponse$inboundSchema, CreateTransferResponse$outboundSchema, CreateTransferResponse$;
 var init_createtransfer2 = __esm(() => {
@@ -53361,6 +53690,66 @@ var init_gettermsofservicetoken = __esm(() => {
   })(GetTermsOfServiceTokenResponse$ ||= {});
 });
 
+// src/models/operations/getticket.ts
+var GetTicketGlobals$inboundSchema, GetTicketGlobals$outboundSchema, GetTicketGlobals$, GetTicketRequest$inboundSchema, GetTicketRequest$outboundSchema, GetTicketRequest$, GetTicketResponse$inboundSchema, GetTicketResponse$outboundSchema, GetTicketResponse$;
+var init_getticket = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  GetTicketGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  GetTicketGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((GetTicketGlobals$) => {
+    GetTicketGlobals$.inboundSchema = GetTicketGlobals$inboundSchema;
+    GetTicketGlobals$.outboundSchema = GetTicketGlobals$outboundSchema;
+  })(GetTicketGlobals$ ||= {});
+  GetTicketRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType()
+  });
+  GetTicketRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType()
+  });
+  ((GetTicketRequest$) => {
+    GetTicketRequest$.inboundSchema = GetTicketRequest$inboundSchema;
+    GetTicketRequest$.outboundSchema = GetTicketRequest$outboundSchema;
+  })(GetTicketRequest$ ||= {});
+  GetTicketResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: Ticket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  GetTicketResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Ticket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((GetTicketResponse$) => {
+    GetTicketResponse$.inboundSchema = GetTicketResponse$inboundSchema;
+    GetTicketResponse$.outboundSchema = GetTicketResponse$outboundSchema;
+  })(GetTicketResponse$ ||= {});
+});
+
 // src/models/operations/gettransfer.ts
 var GetTransferGlobals$inboundSchema, GetTransferGlobals$outboundSchema, GetTransferGlobals$, GetTransferRequest$inboundSchema, GetTransferRequest$outboundSchema, GetTransferRequest$, GetTransferResponse$inboundSchema, GetTransferResponse$outboundSchema, GetTransferResponse$;
 var init_gettransfer = __esm(() => {
@@ -55977,6 +56366,132 @@ var init_listterminalapplications = __esm(() => {
   })(ListTerminalApplicationsResponse$ ||= {});
 });
 
+// src/models/operations/listticketmessages.ts
+var ListTicketMessagesGlobals$inboundSchema, ListTicketMessagesGlobals$outboundSchema, ListTicketMessagesGlobals$, ListTicketMessagesRequest$inboundSchema, ListTicketMessagesRequest$outboundSchema, ListTicketMessagesRequest$, ListTicketMessagesResponse$inboundSchema, ListTicketMessagesResponse$outboundSchema, ListTicketMessagesResponse$;
+var init_listticketmessages = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ListTicketMessagesGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  ListTicketMessagesGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((ListTicketMessagesGlobals$) => {
+    ListTicketMessagesGlobals$.inboundSchema = ListTicketMessagesGlobals$inboundSchema;
+    ListTicketMessagesGlobals$.outboundSchema = ListTicketMessagesGlobals$outboundSchema;
+  })(ListTicketMessagesGlobals$ ||= {});
+  ListTicketMessagesRequest$inboundSchema = objectType({
+    skip: numberType().int().optional(),
+    count: numberType().int().optional(),
+    accountID: stringType(),
+    ticketID: stringType()
+  });
+  ListTicketMessagesRequest$outboundSchema = objectType({
+    skip: numberType().int().optional(),
+    count: numberType().int().optional(),
+    accountID: stringType(),
+    ticketID: stringType()
+  });
+  ((ListTicketMessagesRequest$) => {
+    ListTicketMessagesRequest$.inboundSchema = ListTicketMessagesRequest$inboundSchema;
+    ListTicketMessagesRequest$.outboundSchema = ListTicketMessagesRequest$outboundSchema;
+  })(ListTicketMessagesRequest$ ||= {});
+  ListTicketMessagesResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: arrayType(TicketMessage$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ListTicketMessagesResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: arrayType(TicketMessage$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((ListTicketMessagesResponse$) => {
+    ListTicketMessagesResponse$.inboundSchema = ListTicketMessagesResponse$inboundSchema;
+    ListTicketMessagesResponse$.outboundSchema = ListTicketMessagesResponse$outboundSchema;
+  })(ListTicketMessagesResponse$ ||= {});
+});
+
+// src/models/operations/listtickets.ts
+var ListTicketsGlobals$inboundSchema, ListTicketsGlobals$outboundSchema, ListTicketsGlobals$, ListTicketsRequest$inboundSchema, ListTicketsRequest$outboundSchema, ListTicketsRequest$, ListTicketsResponse$inboundSchema, ListTicketsResponse$outboundSchema, ListTicketsResponse$;
+var init_listtickets = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ListTicketsGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  ListTicketsGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((ListTicketsGlobals$) => {
+    ListTicketsGlobals$.inboundSchema = ListTicketsGlobals$inboundSchema;
+    ListTicketsGlobals$.outboundSchema = ListTicketsGlobals$outboundSchema;
+  })(ListTicketsGlobals$ ||= {});
+  ListTicketsRequest$inboundSchema = objectType({
+    skip: numberType().int().optional(),
+    count: numberType().int().optional(),
+    accountID: stringType()
+  });
+  ListTicketsRequest$outboundSchema = objectType({
+    skip: numberType().int().optional(),
+    count: numberType().int().optional(),
+    accountID: stringType()
+  });
+  ((ListTicketsRequest$) => {
+    ListTicketsRequest$.inboundSchema = ListTicketsRequest$inboundSchema;
+    ListTicketsRequest$.outboundSchema = ListTicketsRequest$outboundSchema;
+  })(ListTicketsRequest$ ||= {});
+  ListTicketsResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: arrayType(Ticket$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ListTicketsResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: arrayType(Ticket$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((ListTicketsResponse$) => {
+    ListTicketsResponse$.inboundSchema = ListTicketsResponse$inboundSchema;
+    ListTicketsResponse$.outboundSchema = ListTicketsResponse$outboundSchema;
+  })(ListTicketsResponse$ ||= {});
+});
+
 // src/models/operations/listtransfers.ts
 var ListTransfersGlobals$inboundSchema, ListTransfersGlobals$outboundSchema, ListTransfersGlobals$, ListTransfersRequest$inboundSchema, ListTransfersRequest$outboundSchema, ListTransfersRequest$, ListTransfersResponse$inboundSchema, ListTransfersResponse$outboundSchema, ListTransfersResponse$;
 var init_listtransfers = __esm(() => {
@@ -57541,6 +58056,76 @@ var init_updatesweepconfig = __esm(() => {
   })(UpdateSweepConfigResponse$ ||= {});
 });
 
+// src/models/operations/updateticket.ts
+var UpdateTicketGlobals$inboundSchema, UpdateTicketGlobals$outboundSchema, UpdateTicketGlobals$, UpdateTicketRequest$inboundSchema, UpdateTicketRequest$outboundSchema, UpdateTicketRequest$, UpdateTicketResponse$inboundSchema, UpdateTicketResponse$outboundSchema, UpdateTicketResponse$;
+var init_updateticket2 = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  UpdateTicketGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  UpdateTicketGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((UpdateTicketGlobals$) => {
+    UpdateTicketGlobals$.inboundSchema = UpdateTicketGlobals$inboundSchema;
+    UpdateTicketGlobals$.outboundSchema = UpdateTicketGlobals$outboundSchema;
+  })(UpdateTicketGlobals$ ||= {});
+  UpdateTicketRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType(),
+    UpdateTicket: UpdateTicket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      UpdateTicket: "updateTicket"
+    });
+  });
+  UpdateTicketRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType(),
+    updateTicket: UpdateTicket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      updateTicket: "UpdateTicket"
+    });
+  });
+  ((UpdateTicketRequest$) => {
+    UpdateTicketRequest$.inboundSchema = UpdateTicketRequest$inboundSchema;
+    UpdateTicketRequest$.outboundSchema = UpdateTicketRequest$outboundSchema;
+  })(UpdateTicketRequest$ ||= {});
+  UpdateTicketResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: Ticket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  UpdateTicketResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Ticket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((UpdateTicketResponse$) => {
+    UpdateTicketResponse$.inboundSchema = UpdateTicketResponse$inboundSchema;
+    UpdateTicketResponse$.outboundSchema = UpdateTicketResponse$outboundSchema;
+  })(UpdateTicketResponse$ ||= {});
+});
+
 // src/models/operations/updatetransfer.ts
 var UpdateTransferGlobals$inboundSchema, UpdateTransferGlobals$outboundSchema, UpdateTransferGlobals$, UpdateTransferRequest$inboundSchema, UpdateTransferRequest$outboundSchema, UpdateTransferRequest$, UpdateTransferResponse$inboundSchema, UpdateTransferResponse$outboundSchema, UpdateTransferResponse$;
 var init_updatetransfer = __esm(() => {
@@ -57976,6 +58561,7 @@ var init_operations = __esm(() => {
   init_createschedule();
   init_createsweepconfig2();
   init_createterminalapplication2();
+  init_createticket2();
   init_createtransfer2();
   init_createtransferoptions2();
   init_createtransferoptionsforaccount();
@@ -58024,6 +58610,7 @@ var init_operations = __esm(() => {
   init_getterminalapplication();
   init_getterminalconfiguration();
   init_gettermsofservicetoken();
+  init_getticket();
   init_gettransfer();
   init_getunderwriting();
   init_getwallet();
@@ -58065,6 +58652,8 @@ var init_operations = __esm(() => {
   init_listsweepconfigs();
   init_listsweeps();
   init_listterminalapplications();
+  init_listticketmessages();
+  init_listtickets();
   init_listtransfers();
   init_listwallets();
   init_listwallettransactions();
@@ -58089,6 +58678,7 @@ var init_operations = __esm(() => {
   init_updaterepresentative2();
   init_updateschedule();
   init_updatesweepconfig();
+  init_updateticket2();
   init_updatetransfer();
   init_uploaddisputeevidencefile();
   init_uploaddisputeevidencetext();
@@ -70727,7 +71317,486 @@ async function $do105(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, CreateScheduleResponse$inboundSchema, {
+  const [result] = await match(json(200, CreateScheduleResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, ScheduleValidationError$inboundSchema, {
+    hdrs: true
+  }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_schedulingCreate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/schedulingCreate.ts
+var args105, tool$schedulingCreate;
+var init_schedulingCreate2 = __esm(() => {
+  init_schedulingCreate();
+  init_operations();
+  init_tools();
+  args105 = {
+    request: CreateScheduleRequest$inboundSchema
+  };
+  tool$schedulingCreate = {
+    name: "scheduling-create",
+    description: `Describes the schedule to create or modify.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
+    args: args105,
+    tool: async (client, args106, ctx) => {
+      const [result, apiCall] = await schedulingCreate(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/schedulingGet.ts
+function schedulingGet(client, request, options) {
+  return new APIPromise($do106(client, request, options));
+}
+async function $do106(client, request, options) {
+  const parsed = safeParse(request, (value) => GetSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    scheduleID: encodeSimple("scheduleID", payload.scheduleID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/schedules/{scheduleID}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getSchedules",
+    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,
+    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: ["401", "403", "404", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, GetSchedulesResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_schedulingGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/schedulingGet.ts
+var args106, tool$schedulingGet;
+var init_schedulingGet2 = __esm(() => {
+  init_schedulingGet();
+  init_operations();
+  init_tools();
+  args106 = {
+    request: GetSchedulesRequest$inboundSchema
+  };
+  tool$schedulingGet = {
+    name: "scheduling-get",
+    description: `Describes a schedule associated with an account. Requires at least 1 occurrence or recurTransfer to be specified.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
+    args: args106,
+    tool: async (client, args107, ctx) => {
+      const [result, apiCall] = await schedulingGet(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/schedulingGetOccurrance.ts
+function schedulingGetOccurrance(client, request, options) {
+  return new APIPromise($do107(client, request, options));
+}
+async function $do107(client, request, options) {
+  const parsed = safeParse(request, (value) => GetScheduledOccurrenceRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    occurrenceFilter: encodeSimple("occurrenceFilter", payload.occurrenceFilter, { explode: false, charEncoding: "percent" }),
+    scheduleID: encodeSimple("scheduleID", payload.scheduleID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/schedules/{scheduleID}/occurrences/{occurrenceFilter}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getScheduledOccurrence",
+    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,
+    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: ["401", "403", "404", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, GetScheduledOccurrenceResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_schedulingGetOccurrance = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/schedulingGetOccurrance.ts
+var args107, tool$schedulingGetOccurrance;
+var init_schedulingGetOccurrance2 = __esm(() => {
+  init_schedulingGetOccurrance();
+  init_operations();
+  init_tools();
+  args107 = {
+    request: GetScheduledOccurrenceRequest$inboundSchema
+  };
+  tool$schedulingGetOccurrance = {
+    name: "scheduling-get-occurrance",
+    description: `Gets a specific occurrence.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
+    args: args107,
+    tool: async (client, args108, ctx) => {
+      const [result, apiCall] = await schedulingGetOccurrance(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/schedulingList.ts
+function schedulingList(client, request, options) {
+  return new APIPromise($do108(client, request, options));
+}
+async function $do108(client, request, options) {
+  const parsed = safeParse(request, (value) => ListSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/schedules")(pathParams);
+  const query = encodeFormQuery({
+    count: payload.count,
+    hydrate: payload.hydrate,
+    skip: payload.skip
+  }, { explode: false });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listSchedules",
+    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: ["401", "403", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, ListSchedulesResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_schedulingList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/schedulingList.ts
+var args108, tool$schedulingList;
+var init_schedulingList2 = __esm(() => {
+  init_schedulingList();
+  init_operations();
+  init_tools();
+  args108 = {
+    request: ListSchedulesRequest$inboundSchema
+  };
+  tool$schedulingList = {
+    name: "scheduling-list",
+    description: `Describes a list of schedules associated with an account. Append the \`hydrate=accounts\` query parameter to include partial account details in the response.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
+    args: args108,
+    tool: async (client, args109, ctx) => {
+      const [result, apiCall] = await schedulingList(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/schedulingUpdate.ts
+function schedulingUpdate(client, request, options) {
+  return new APIPromise($do109(client, request, options));
+}
+async function $do109(client, request, options) {
+  const parsed = safeParse(request, (value) => UpdateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.UpsertSchedule, { explode: true });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    scheduleID: encodeSimple("scheduleID", payload.scheduleID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/schedules/{scheduleID}")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "updateSchedule",
+    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: "PUT",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, UpdateScheduleResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
   }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, ScheduleValidationError$inboundSchema, {
@@ -70738,7 +71807,7 @@ async function $do105(client, request, options) {
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_schedulingCreate = __esm(() => {
+var init_schedulingUpdate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -70750,24 +71819,24 @@ var init_schedulingCreate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/schedulingCreate.ts
-var args105, tool$schedulingCreate;
-var init_schedulingCreate2 = __esm(() => {
-  init_schedulingCreate();
+// src/mcp-server/tools/schedulingUpdate.ts
+var args109, tool$schedulingUpdate;
+var init_schedulingUpdate2 = __esm(() => {
+  init_schedulingUpdate();
   init_operations();
   init_tools();
-  args105 = {
-    request: CreateScheduleRequest$inboundSchema
+  args109 = {
+    request: UpdateScheduleRequest$inboundSchema
   };
-  tool$schedulingCreate = {
-    name: "scheduling-create",
-    description: `Describes the schedule to create or modify.
+  tool$schedulingUpdate = {
+    name: "scheduling-update",
+    description: `Describes the schedule to modify.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args105,
-    tool: async (client, args106, ctx) => {
-      const [result, apiCall] = await schedulingCreate(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args109,
+    tool: async (client, args110, ctx) => {
+      const [result, apiCall] = await schedulingUpdate(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70780,12 +71849,137 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
   };
 });
 
-// src/funcs/schedulingGet.ts
-function schedulingGet(client, request, options) {
-  return new APIPromise($do106(client, request, options));
+// src/funcs/supportCreateTicket.ts
+function supportCreateTicket(client, request, options) {
+  return new APIPromise($do110(client, request, options));
 }
-async function $do106(client, request, options) {
-  const parsed = safeParse(request, (value) => GetSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do110(client, request, options) {
+  const parsed = safeParse(request, (value) => CreateTicketRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.CreateTicket, { explode: true });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/tickets")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "createTicket",
+    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: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    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: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, CreateTicketResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, CreateTicketError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_supportCreateTicket = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/supportCreateTicket.ts
+var args110, tool$supportCreateTicket;
+var init_supportCreateTicket2 = __esm(() => {
+  init_supportCreateTicket();
+  init_operations();
+  init_tools();
+  args110 = {
+    request: CreateTicketRequest$inboundSchema
+  };
+  tool$supportCreateTicket = {
+    name: "support-create-ticket",
+    description: `Create a support ticket for a Moov account.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/support.write\` scope.`,
+    args: args110,
+    tool: async (client, args111, ctx) => {
+      const [result, apiCall] = await supportCreateTicket(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/supportGetTicket.ts
+function supportGetTicket(client, request, options) {
+  return new APIPromise($do111(client, request, options));
+}
+async function $do111(client, request, options) {
+  const parsed = safeParse(request, (value) => GetTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -70796,12 +71990,12 @@ async function $do106(client, request, options) {
       explode: false,
       charEncoding: "percent"
     }),
-    scheduleID: encodeSimple("scheduleID", payload.scheduleID, {
+    ticketID: encodeSimple("ticketID", payload.ticketID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/schedules/{scheduleID}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets/{ticketID}")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
@@ -70811,7 +72005,7 @@ async function $do106(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getSchedules",
+    operationID: "getTicket",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -70845,7 +72039,7 @@ async function $do106(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, GetSchedulesResponse$inboundSchema, {
+  const [result] = await match(json(200, GetTicketResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
   }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
@@ -70854,7 +72048,7 @@ async function $do106(client, request, options) {
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_schedulingGet = __esm(() => {
+var init_supportGetTicket = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -70865,24 +72059,24 @@ var init_schedulingGet = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/schedulingGet.ts
-var args106, tool$schedulingGet;
-var init_schedulingGet2 = __esm(() => {
-  init_schedulingGet();
+// src/mcp-server/tools/supportGetTicket.ts
+var args111, tool$supportGetTicket;
+var init_supportGetTicket2 = __esm(() => {
+  init_supportGetTicket();
   init_operations();
   init_tools();
-  args106 = {
-    request: GetSchedulesRequest$inboundSchema
+  args111 = {
+    request: GetTicketRequest$inboundSchema
   };
-  tool$schedulingGet = {
-    name: "scheduling-get",
-    description: `Describes a schedule associated with an account. Requires at least 1 occurrence or recurTransfer to be specified.
+  tool$supportGetTicket = {
+    name: "support-get-ticket",
+    description: `Retrieve a support ticket by ID.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args106,
-    tool: async (client, args107, ctx) => {
-      const [result, apiCall] = await schedulingGet(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+you'll need to specify the \`/accounts/{accountID}/support.read\` scope.`,
+    args: args111,
+    tool: async (client, args112, ctx) => {
+      const [result, apiCall] = await supportGetTicket(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70895,12 +72089,12 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
   };
 });
 
-// src/funcs/schedulingGetOccurrance.ts
-function schedulingGetOccurrance(client, request, options) {
-  return new APIPromise($do107(client, request, options));
+// src/funcs/supportListTicketMessages.ts
+function supportListTicketMessages(client, request, options) {
+  return new APIPromise($do112(client, request, options));
 }
-async function $do107(client, request, options) {
-  const parsed = safeParse(request, (value) => GetScheduledOccurrenceRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do112(client, request, options) {
+  const parsed = safeParse(request, (value) => ListTicketMessagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -70911,13 +72105,16 @@ async function $do107(client, request, options) {
       explode: false,
       charEncoding: "percent"
     }),
-    occurrenceFilter: encodeSimple("occurrenceFilter", payload.occurrenceFilter, { explode: false, charEncoding: "percent" }),
-    scheduleID: encodeSimple("scheduleID", payload.scheduleID, {
+    ticketID: encodeSimple("ticketID", payload.ticketID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/schedules/{scheduleID}/occurrences/{occurrenceFilter}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets/{ticketID}/messages")(pathParams);
+  const query = encodeFormQuery({
+    count: payload.count,
+    skip: payload.skip
+  }, { explode: false });
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
@@ -70927,7 +72124,7 @@ async function $do107(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getScheduledOccurrence",
+    operationID: "listTicketMessages",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -70940,6 +72137,7 @@ async function $do107(client, request, options) {
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -70950,7 +72148,7 @@ async function $do107(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["401", "403", "404", "429", "4XX", "500", "504", "5XX"],
+    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -70961,16 +72159,16 @@ async function $do107(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, GetScheduledOccurrenceResponse$inboundSchema, {
+  const [result] = await match(json(200, ListTicketMessagesResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
-  }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_schedulingGetOccurrance = __esm(() => {
+var init_supportListTicketMessages = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -70981,24 +72179,24 @@ var init_schedulingGetOccurrance = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/schedulingGetOccurrance.ts
-var args107, tool$schedulingGetOccurrance;
-var init_schedulingGetOccurrance2 = __esm(() => {
-  init_schedulingGetOccurrance();
+// src/mcp-server/tools/supportListTicketMessages.ts
+var args112, tool$supportListTicketMessages;
+var init_supportListTicketMessages2 = __esm(() => {
+  init_supportListTicketMessages();
   init_operations();
   init_tools();
-  args107 = {
-    request: GetScheduledOccurrenceRequest$inboundSchema
+  args112 = {
+    request: ListTicketMessagesRequest$inboundSchema
   };
-  tool$schedulingGetOccurrance = {
-    name: "scheduling-get-occurrance",
-    description: `Gets a specific occurrence.
+  tool$supportListTicketMessages = {
+    name: "support-list-ticket-messages",
+    description: `List all the messages for a support ticket.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args107,
-    tool: async (client, args108, ctx) => {
-      const [result, apiCall] = await schedulingGetOccurrance(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+you'll need to specify the \`/accounts/{accountID}/support.read\` scope.`,
+    args: args112,
+    tool: async (client, args113, ctx) => {
+      const [result, apiCall] = await supportListTicketMessages(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71011,12 +72209,12 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
   };
 });
 
-// src/funcs/schedulingList.ts
-function schedulingList(client, request, options) {
-  return new APIPromise($do108(client, request, options));
+// src/funcs/supportListTickets.ts
+function supportListTickets(client, request, options) {
+  return new APIPromise($do113(client, request, options));
 }
-async function $do108(client, request, options) {
-  const parsed = safeParse(request, (value) => ListSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do113(client, request, options) {
+  const parsed = safeParse(request, (value) => ListTicketsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -71028,10 +72226,9 @@ async function $do108(client, request, options) {
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/schedules")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets")(pathParams);
   const query = encodeFormQuery({
     count: payload.count,
-    hydrate: payload.hydrate,
     skip: payload.skip
   }, { explode: false });
   const headers = new Headers(compactMap({
@@ -71043,7 +72240,7 @@ async function $do108(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "listSchedules",
+    operationID: "listTickets",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -71078,7 +72275,7 @@ async function $do108(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, ListSchedulesResponse$inboundSchema, {
+  const [result] = await match(json(200, ListTicketsResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
   }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
@@ -71087,7 +72284,7 @@ async function $do108(client, request, options) {
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_schedulingList = __esm(() => {
+var init_supportListTickets = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -71098,24 +72295,24 @@ var init_schedulingList = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/schedulingList.ts
-var args108, tool$schedulingList;
-var init_schedulingList2 = __esm(() => {
-  init_schedulingList();
+// src/mcp-server/tools/supportListTickets.ts
+var args113, tool$supportListTickets;
+var init_supportListTickets2 = __esm(() => {
+  init_supportListTickets();
   init_operations();
   init_tools();
-  args108 = {
-    request: ListSchedulesRequest$inboundSchema
+  args113 = {
+    request: ListTicketsRequest$inboundSchema
   };
-  tool$schedulingList = {
-    name: "scheduling-list",
-    description: `Describes a list of schedules associated with an account. Append the \`hydrate=accounts\` query parameter to include partial account details in the response.
+  tool$supportListTickets = {
+    name: "support-list-tickets",
+    description: `List all the support tickets created under a Moov account.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args108,
-    tool: async (client, args109, ctx) => {
-      const [result, apiCall] = await schedulingList(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+you'll need to specify the \`/accounts/{accountID}/support.read\` scope.`,
+    args: args113,
+    tool: async (client, args114, ctx) => {
+      const [result, apiCall] = await supportListTickets(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71128,28 +72325,28 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
   };
 });
 
-// src/funcs/schedulingUpdate.ts
-function schedulingUpdate(client, request, options) {
-  return new APIPromise($do109(client, request, options));
+// src/funcs/supportUpdateTicket.ts
+function supportUpdateTicket(client, request, options) {
+  return new APIPromise($do114(client, request, options));
 }
-async function $do109(client, request, options) {
-  const parsed = safeParse(request, (value) => UpdateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do114(client, request, options) {
+  const parsed = safeParse(request, (value) => UpdateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.UpsertSchedule, { explode: true });
+  const body = encodeJSON("body", payload.UpdateTicket, { explode: true });
   const pathParams = {
     accountID: encodeSimple("accountID", payload.accountID, {
       explode: false,
       charEncoding: "percent"
     }),
-    scheduleID: encodeSimple("scheduleID", payload.scheduleID, {
+    ticketID: encodeSimple("ticketID", payload.ticketID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/schedules/{scheduleID}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets/{ticketID}")(pathParams);
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/json",
@@ -71160,7 +72357,7 @@ async function $do109(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "updateSchedule",
+    operationID: "updateTicket",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -71169,7 +72366,7 @@ async function $do109(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "PUT",
+    method: "PATCH",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -71206,18 +72403,16 @@ async function $do109(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, UpdateScheduleResponse$inboundSchema, {
+  const [result] = await match(json(200, UpdateTicketResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
-  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, ScheduleValidationError$inboundSchema, {
-    hdrs: true
-  }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, UpdateTicketError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_schedulingUpdate = __esm(() => {
+var init_supportUpdateTicket = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -71229,24 +72424,24 @@ var init_schedulingUpdate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/schedulingUpdate.ts
-var args109, tool$schedulingUpdate;
-var init_schedulingUpdate2 = __esm(() => {
-  init_schedulingUpdate();
+// src/mcp-server/tools/supportUpdateTicket.ts
+var args114, tool$supportUpdateTicket;
+var init_supportUpdateTicket2 = __esm(() => {
+  init_supportUpdateTicket();
   init_operations();
   init_tools();
-  args109 = {
-    request: UpdateScheduleRequest$inboundSchema
+  args114 = {
+    request: UpdateTicketRequest$inboundSchema
   };
-  tool$schedulingUpdate = {
-    name: "scheduling-update",
-    description: `Describes the schedule to modify.
+  tool$supportUpdateTicket = {
+    name: "support-update-ticket",
+    description: `Updates a support ticket.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args109,
-    tool: async (client, args110, ctx) => {
-      const [result, apiCall] = await schedulingUpdate(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+you'll need to specify the \`/accounts/{accountID}/support.write\` scope.`,
+    args: args114,
+    tool: async (client, args115, ctx) => {
+      const [result, apiCall] = await supportUpdateTicket(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71261,9 +72456,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/sweepsCreateConfig.ts
 function sweepsCreateConfig(client, request, options) {
-  return new APIPromise($do110(client, request, options));
+  return new APIPromise($do115(client, request, options));
 }
-async function $do110(client, request, options) {
+async function $do115(client, request, options) {
   const parsed = safeParse(request, (value) => CreateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71355,12 +72550,12 @@ var init_sweepsCreateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsCreateConfig.ts
-var args110, tool$sweepsCreateConfig;
+var args115, tool$sweepsCreateConfig;
 var init_sweepsCreateConfig2 = __esm(() => {
   init_sweepsCreateConfig();
   init_operations();
   init_tools();
-  args110 = {
+  args115 = {
     request: CreateSweepConfigRequest$inboundSchema
   };
   tool$sweepsCreateConfig = {
@@ -71369,9 +72564,9 @@ var init_sweepsCreateConfig2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
-    args: args110,
-    tool: async (client, args111, ctx) => {
-      const [result, apiCall] = await sweepsCreateConfig(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args115,
+    tool: async (client, args116, ctx) => {
+      const [result, apiCall] = await sweepsCreateConfig(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71386,9 +72581,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/sweepsGet.ts
 function sweepsGet(client, request, options) {
-  return new APIPromise($do111(client, request, options));
+  return new APIPromise($do116(client, request, options));
 }
-async function $do111(client, request, options) {
+async function $do116(client, request, options) {
   const parsed = safeParse(request, (value) => GetSweepRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71474,12 +72669,12 @@ var init_sweepsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGet.ts
-var args111, tool$sweepsGet;
+var args116, tool$sweepsGet;
 var init_sweepsGet2 = __esm(() => {
   init_sweepsGet();
   init_operations();
   init_tools();
-  args111 = {
+  args116 = {
     request: GetSweepRequest$inboundSchema
   };
   tool$sweepsGet = {
@@ -71488,9 +72683,9 @@ var init_sweepsGet2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
-    args: args111,
-    tool: async (client, args112, ctx) => {
-      const [result, apiCall] = await sweepsGet(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args116,
+    tool: async (client, args117, ctx) => {
+      const [result, apiCall] = await sweepsGet(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71505,9 +72700,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsGetConfig.ts
 function sweepsGetConfig(client, request, options) {
-  return new APIPromise($do112(client, request, options));
+  return new APIPromise($do117(client, request, options));
 }
-async function $do112(client, request, options) {
+async function $do117(client, request, options) {
   const parsed = safeParse(request, (value) => GetSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71589,12 +72784,12 @@ var init_sweepsGetConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGetConfig.ts
-var args112, tool$sweepsGetConfig;
+var args117, tool$sweepsGetConfig;
 var init_sweepsGetConfig2 = __esm(() => {
   init_sweepsGetConfig();
   init_operations();
   init_tools();
-  args112 = {
+  args117 = {
     request: GetSweepConfigRequest$inboundSchema
   };
   tool$sweepsGetConfig = {
@@ -71603,9 +72798,9 @@ var init_sweepsGetConfig2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
-    args: args112,
-    tool: async (client, args113, ctx) => {
-      const [result, apiCall] = await sweepsGetConfig(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args117,
+    tool: async (client, args118, ctx) => {
+      const [result, apiCall] = await sweepsGetConfig(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71620,9 +72815,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsList.ts
 function sweepsList(client, request, options) {
-  return new APIPromise($do113(client, request, options));
+  return new APIPromise($do118(client, request, options));
 }
-async function $do113(client, request, options) {
+async function $do118(client, request, options) {
   const parsed = safeParse(request, (value) => ListSweepsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71711,12 +72906,12 @@ var init_sweepsList = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsList.ts
-var args113, tool$sweepsList;
+var args118, tool$sweepsList;
 var init_sweepsList2 = __esm(() => {
   init_sweepsList();
   init_operations();
   init_tools();
-  args113 = {
+  args118 = {
     request: ListSweepsRequest$inboundSchema
   };
   tool$sweepsList = {
@@ -71725,9 +72920,9 @@ var init_sweepsList2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
-    args: args113,
-    tool: async (client, args114, ctx) => {
-      const [result, apiCall] = await sweepsList(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args118,
+    tool: async (client, args119, ctx) => {
+      const [result, apiCall] = await sweepsList(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71742,9 +72937,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsListConfigs.ts
 function sweepsListConfigs(client, request, options) {
-  return new APIPromise($do114(client, request, options));
+  return new APIPromise($do119(client, request, options));
 }
-async function $do114(client, request, options) {
+async function $do119(client, request, options) {
   const parsed = safeParse(request, (value) => ListSweepConfigsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71822,12 +73017,12 @@ var init_sweepsListConfigs = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsListConfigs.ts
-var args114, tool$sweepsListConfigs;
+var args119, tool$sweepsListConfigs;
 var init_sweepsListConfigs2 = __esm(() => {
   init_sweepsListConfigs();
   init_operations();
   init_tools();
-  args114 = {
+  args119 = {
     request: ListSweepConfigsRequest$inboundSchema
   };
   tool$sweepsListConfigs = {
@@ -71836,9 +73031,9 @@ var init_sweepsListConfigs2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
-    args: args114,
-    tool: async (client, args115, ctx) => {
-      const [result, apiCall] = await sweepsListConfigs(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args119,
+    tool: async (client, args120, ctx) => {
+      const [result, apiCall] = await sweepsListConfigs(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71853,9 +73048,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsUpdateConfig.ts
 function sweepsUpdateConfig(client, request, options) {
-  return new APIPromise($do115(client, request, options));
+  return new APIPromise($do120(client, request, options));
 }
-async function $do115(client, request, options) {
+async function $do120(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71951,12 +73146,12 @@ var init_sweepsUpdateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsUpdateConfig.ts
-var args115, tool$sweepsUpdateConfig;
+var args120, tool$sweepsUpdateConfig;
 var init_sweepsUpdateConfig2 = __esm(() => {
   init_sweepsUpdateConfig();
   init_operations();
   init_tools();
-  args115 = {
+  args120 = {
     request: UpdateSweepConfigRequest$inboundSchema
   };
   tool$sweepsUpdateConfig = {
@@ -71965,9 +73160,9 @@ var init_sweepsUpdateConfig2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
-    args: args115,
-    tool: async (client, args116, ctx) => {
-      const [result, apiCall] = await sweepsUpdateConfig(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args120,
+    tool: async (client, args121, ctx) => {
+      const [result, apiCall] = await sweepsUpdateConfig(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71982,9 +73177,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreate.ts
 function terminalApplicationsCreate(client, request, options) {
-  return new APIPromise($do116(client, request, options));
+  return new APIPromise($do121(client, request, options));
 }
-async function $do116(client, request, options) {
+async function $do121(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTerminalApplication$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72073,12 +73268,12 @@ var init_terminalApplicationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreate.ts
-var args116, tool$terminalApplicationsCreate;
+var args121, tool$terminalApplicationsCreate;
 var init_terminalApplicationsCreate2 = __esm(() => {
   init_terminalApplicationsCreate();
   init_components();
   init_tools();
-  args116 = {
+  args121 = {
     request: CreateTerminalApplication$inboundSchema
   };
   tool$terminalApplicationsCreate = {
@@ -72087,9 +73282,9 @@ var init_terminalApplicationsCreate2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/terminal-applications.write\` scope.`,
-    args: args116,
-    tool: async (client, args117, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreate(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args121,
+    tool: async (client, args122, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreate(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72104,9 +73299,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsDelete.ts
 function terminalApplicationsDelete(client, request, options) {
-  return new APIPromise($do117(client, request, options));
+  return new APIPromise($do122(client, request, options));
 }
-async function $do117(client, request, options) {
+async function $do122(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72190,12 +73385,12 @@ var init_terminalApplicationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsDelete.ts
-var args117, tool$terminalApplicationsDelete;
+var args122, tool$terminalApplicationsDelete;
 var init_terminalApplicationsDelete2 = __esm(() => {
   init_terminalApplicationsDelete();
   init_operations();
   init_tools();
-  args117 = {
+  args122 = {
     request: DeleteTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsDelete = {
@@ -72204,9 +73399,9 @@ var init_terminalApplicationsDelete2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/terminal-applications.write\` scope.`,
-    args: args117,
-    tool: async (client, args118, ctx) => {
-      const [result, apiCall] = await terminalApplicationsDelete(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args122,
+    tool: async (client, args123, ctx) => {
+      const [result, apiCall] = await terminalApplicationsDelete(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72220,9 +73415,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsGet.ts
 function terminalApplicationsGet(client, request, options) {
-  return new APIPromise($do118(client, request, options));
+  return new APIPromise($do123(client, request, options));
 }
-async function $do118(client, request, options) {
+async function $do123(client, request, options) {
   const parsed = safeParse(request, (value) => GetTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72297,12 +73492,12 @@ var init_terminalApplicationsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsGet.ts
-var args118, tool$terminalApplicationsGet;
+var args123, tool$terminalApplicationsGet;
 var init_terminalApplicationsGet2 = __esm(() => {
   init_terminalApplicationsGet();
   init_operations();
   init_tools();
-  args118 = {
+  args123 = {
     request: GetTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsGet = {
@@ -72311,9 +73506,9 @@ var init_terminalApplicationsGet2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/terminal-applications.read\` scope.`,
-    args: args118,
-    tool: async (client, args119, ctx) => {
-      const [result, apiCall] = await terminalApplicationsGet(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args123,
+    tool: async (client, args124, ctx) => {
+      const [result, apiCall] = await terminalApplicationsGet(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72328,9 +73523,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/terminalApplicationsList.ts
 function terminalApplicationsList(client, _request, options) {
-  return new APIPromise($do119(client, _request, options));
+  return new APIPromise($do124(client, _request, options));
 }
-async function $do119(client, _request, options) {
+async function $do124(client, _request, options) {
   const path = pathToFunc("/terminal-applications")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -72394,12 +73589,12 @@ var init_terminalApplicationsList = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsList.ts
-var args119, tool$terminalApplicationsList;
+var args124, tool$terminalApplicationsList;
 var init_terminalApplicationsList2 = __esm(() => {
   init_terminalApplicationsList();
   init_operations();
   init_tools();
-  args119 = {
+  args124 = {
     request: ListTerminalApplicationsRequest$inboundSchema
   };
   tool$terminalApplicationsList = {
@@ -72408,9 +73603,9 @@ var init_terminalApplicationsList2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/terminal-applications.read\` scope.`,
-    args: args119,
-    tool: async (client, args120, ctx) => {
-      const [result, apiCall] = await terminalApplicationsList(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args124,
+    tool: async (client, args125, ctx) => {
+      const [result, apiCall] = await terminalApplicationsList(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72425,9 +73620,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/transfersCreate.ts
 function transfersCreate(client, request, options) {
-  return new APIPromise($do120(client, request, options));
+  return new APIPromise($do125(client, request, options));
 }
-async function $do120(client, request, options) {
+async function $do125(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72520,12 +73715,12 @@ var init_transfersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreate.ts
-var args120, tool$transfersCreate;
+var args125, tool$transfersCreate;
 var init_transfersCreate2 = __esm(() => {
   init_transfersCreate();
   init_operations();
   init_tools();
-  args120 = {
+  args125 = {
     request: CreateTransferRequest$inboundSchema
   };
   tool$transfersCreate = {
@@ -72536,9 +73731,9 @@ Read our [transfers overview guide](https://docs.moov.io/guides/money-movement/o
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args120,
-    tool: async (client, args121, ctx) => {
-      const [result, apiCall] = await transfersCreate(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args125,
+    tool: async (client, args126, ctx) => {
+      const [result, apiCall] = await transfersCreate(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72553,9 +73748,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersCreateCancellation.ts
 function transfersCreateCancellation(client, request, options) {
-  return new APIPromise($do121(client, request, options));
+  return new APIPromise($do126(client, request, options));
 }
-async function $do121(client, request, options) {
+async function $do126(client, request, options) {
   const parsed = safeParse(request, (value) => CreateCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72638,12 +73833,12 @@ var init_transfersCreateCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateCancellation.ts
-var args121, tool$transfersCreateCancellation;
+var args126, tool$transfersCreateCancellation;
 var init_transfersCreateCancellation2 = __esm(() => {
   init_transfersCreateCancellation();
   init_operations();
   init_tools();
-  args121 = {
+  args126 = {
     request: CreateCancellationRequest$inboundSchema
   };
   tool$transfersCreateCancellation = {
@@ -72652,9 +73847,9 @@ var init_transfersCreateCancellation2 = __esm(() => {
   
   To access this endpoint using a [token](https://docs.moov.io/api/authentication/access-tokens/) you'll need 
   to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args121,
-    tool: async (client, args122, ctx) => {
-      const [result, apiCall] = await transfersCreateCancellation(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args126,
+    tool: async (client, args127, ctx) => {
+      const [result, apiCall] = await transfersCreateCancellation(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72669,9 +73864,9 @@ var init_transfersCreateCancellation2 = __esm(() => {
 
 // src/funcs/transfersCreateReversal.ts
 function transfersCreateReversal(client, request, options) {
-  return new APIPromise($do122(client, request, options));
+  return new APIPromise($do127(client, request, options));
 }
-async function $do122(client, request, options) {
+async function $do127(client, request, options) {
   const parsed = safeParse(request, (value) => CreateReversalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72770,12 +73965,12 @@ var init_transfersCreateReversal = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateReversal.ts
-var args122, tool$transfersCreateReversal;
+var args127, tool$transfersCreateReversal;
 var init_transfersCreateReversal2 = __esm(() => {
   init_transfersCreateReversal();
   init_operations();
   init_tools();
-  args122 = {
+  args127 = {
     request: CreateReversalRequest$inboundSchema
   };
   tool$transfersCreateReversal = {
@@ -72786,9 +73981,9 @@ to learn more.
 
 To access this endpoint using a [token](https://docs.moov.io/api/authentication/access-tokens/) you'll need 
 to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args122,
-    tool: async (client, args123, ctx) => {
-      const [result, apiCall] = await transfersCreateReversal(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args127,
+    tool: async (client, args128, ctx) => {
+      const [result, apiCall] = await transfersCreateReversal(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72803,9 +73998,9 @@ to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGenerateOptions.ts
 function transfersGenerateOptions(client, request, options) {
-  return new APIPromise($do123(client, request, options));
+  return new APIPromise($do128(client, request, options));
 }
-async function $do123(client, request, options) {
+async function $do128(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTransferOptions$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72882,12 +74077,12 @@ var init_transfersGenerateOptions = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGenerateOptions.ts
-var args123, tool$transfersGenerateOptions;
+var args128, tool$transfersGenerateOptions;
 var init_transfersGenerateOptions2 = __esm(() => {
   init_transfersGenerateOptions();
   init_components();
   init_tools();
-  args123 = {
+  args128 = {
     request: CreateTransferOptions$inboundSchema
   };
   tool$transfersGenerateOptions = {
@@ -72899,9 +74094,9 @@ Read our [transfers overview guide](https://docs.moov.io/guides/money-movement/o
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args123,
-    tool: async (client, args124, ctx) => {
-      const [result, apiCall] = await transfersGenerateOptions(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args128,
+    tool: async (client, args129, ctx) => {
+      const [result, apiCall] = await transfersGenerateOptions(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72916,9 +74111,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGenerateOptionsForAccount.ts
 function transfersGenerateOptionsForAccount(client, request, options) {
-  return new APIPromise($do124(client, request, options));
+  return new APIPromise($do129(client, request, options));
 }
-async function $do124(client, request, options) {
+async function $do129(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTransferOptionsForAccountRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72999,12 +74194,12 @@ var init_transfersGenerateOptionsForAccount = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGenerateOptionsForAccount.ts
-var args124, tool$transfersGenerateOptionsForAccount;
+var args129, tool$transfersGenerateOptionsForAccount;
 var init_transfersGenerateOptionsForAccount2 = __esm(() => {
   init_transfersGenerateOptionsForAccount();
   init_operations();
   init_tools();
-  args124 = {
+  args129 = {
     request: CreateTransferOptionsForAccountRequest$inboundSchema
   };
   tool$transfersGenerateOptionsForAccount = {
@@ -73018,9 +74213,9 @@ Read our [transfers overview guide](https://docs.moov.io/guides/money-movement/o
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args124,
-    tool: async (client, args125, ctx) => {
-      const [result, apiCall] = await transfersGenerateOptionsForAccount(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args129,
+    tool: async (client, args130, ctx) => {
+      const [result, apiCall] = await transfersGenerateOptionsForAccount(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73035,9 +74230,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGet.ts
 function transfersGet(client, request, options) {
-  return new APIPromise($do125(client, request, options));
+  return new APIPromise($do130(client, request, options));
 }
-async function $do125(client, request, options) {
+async function $do130(client, request, options) {
   const parsed = safeParse(request, (value) => GetTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73119,12 +74314,12 @@ var init_transfersGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGet.ts
-var args125, tool$transfersGet;
+var args130, tool$transfersGet;
 var init_transfersGet2 = __esm(() => {
   init_transfersGet();
   init_operations();
   init_tools();
-  args125 = {
+  args130 = {
     request: GetTransferRequest$inboundSchema
   };
   tool$transfersGet = {
@@ -73136,9 +74331,9 @@ to learn more.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args125,
-    tool: async (client, args126, ctx) => {
-      const [result, apiCall] = await transfersGet(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args130,
+    tool: async (client, args131, ctx) => {
+      const [result, apiCall] = await transfersGet(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73153,9 +74348,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersGetCancellation.ts
 function transfersGetCancellation(client, request, options) {
-  return new APIPromise($do126(client, request, options));
+  return new APIPromise($do131(client, request, options));
 }
-async function $do126(client, request, options) {
+async function $do131(client, request, options) {
   const parsed = safeParse(request, (value) => GetCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73241,12 +74436,12 @@ var init_transfersGetCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetCancellation.ts
-var args126, tool$transfersGetCancellation;
+var args131, tool$transfersGetCancellation;
 var init_transfersGetCancellation2 = __esm(() => {
   init_transfersGetCancellation();
   init_operations();
   init_tools();
-  args126 = {
+  args131 = {
     request: GetCancellationRequest$inboundSchema
   };
   tool$transfersGetCancellation = {
@@ -73255,9 +74450,9 @@ var init_transfersGetCancellation2 = __esm(() => {
   
   To access this endpoint using a [token](https://docs.moov.io/api/authentication/access-tokens/) you'll need 
   to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args126,
-    tool: async (client, args127, ctx) => {
-      const [result, apiCall] = await transfersGetCancellation(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args131,
+    tool: async (client, args132, ctx) => {
+      const [result, apiCall] = await transfersGetCancellation(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73272,9 +74467,9 @@ var init_transfersGetCancellation2 = __esm(() => {
 
 // src/funcs/transfersGetRefund.ts
 function transfersGetRefund(client, request, options) {
-  return new APIPromise($do127(client, request, options));
+  return new APIPromise($do132(client, request, options));
 }
-async function $do127(client, request, options) {
+async function $do132(client, request, options) {
   const parsed = safeParse(request, (value) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73360,12 +74555,12 @@ var init_transfersGetRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetRefund.ts
-var args127, tool$transfersGetRefund;
+var args132, tool$transfersGetRefund;
 var init_transfersGetRefund2 = __esm(() => {
   init_transfersGetRefund();
   init_operations();
   init_tools();
-  args127 = {
+  args132 = {
     request: GetRefundRequest$inboundSchema
   };
   tool$transfersGetRefund = {
@@ -73374,9 +74569,9 @@ var init_transfersGetRefund2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args127,
-    tool: async (client, args128, ctx) => {
-      const [result, apiCall] = await transfersGetRefund(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args132,
+    tool: async (client, args133, ctx) => {
+      const [result, apiCall] = await transfersGetRefund(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73391,9 +74586,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersInitiateRefund.ts
 function transfersInitiateRefund(client, request, options) {
-  return new APIPromise($do128(client, request, options));
+  return new APIPromise($do133(client, request, options));
 }
-async function $do128(client, request, options) {
+async function $do133(client, request, options) {
   const parsed = safeParse(request, (value) => InitiateRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73485,12 +74680,12 @@ var init_transfersInitiateRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersInitiateRefund.ts
-var args128, tool$transfersInitiateRefund;
+var args133, tool$transfersInitiateRefund;
 var init_transfersInitiateRefund2 = __esm(() => {
   init_transfersInitiateRefund();
   init_operations();
   init_tools();
-  args128 = {
+  args133 = {
     request: InitiateRefundRequest$inboundSchema
   };
   tool$transfersInitiateRefund = {
@@ -73502,9 +74697,9 @@ See the [reversals](https://docs.moov.io/guides/money-movement/accept-payments/c
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args128,
-    tool: async (client, args129, ctx) => {
-      const [result, apiCall] = await transfersInitiateRefund(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await transfersInitiateRefund(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73519,9 +74714,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersList.ts
 function transfersList(client, request, options) {
-  return new APIPromise($do129(client, request, options));
+  return new APIPromise($do134(client, request, options));
 }
-async function $do129(client, request, options) {
+async function $do134(client, request, options) {
   const parsed = safeParse(request, (value) => ListTransfersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73614,12 +74809,12 @@ var init_transfersList = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersList.ts
-var args129, tool$transfersList;
+var args134, tool$transfersList;
 var init_transfersList2 = __esm(() => {
   init_transfersList();
   init_operations();
   init_tools();
-  args129 = {
+  args134 = {
     request: ListTransfersRequest$inboundSchema
   };
   tool$transfersList = {
@@ -73635,9 +74830,9 @@ period of time. You can run multiple requests in smaller time window increments
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args129,
-    tool: async (client, args130, ctx) => {
-      const [result, apiCall] = await transfersList(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await transfersList(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73652,9 +74847,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersListRefunds.ts
 function transfersListRefunds(client, request, options) {
-  return new APIPromise($do130(client, request, options));
+  return new APIPromise($do135(client, request, options));
 }
-async function $do130(client, request, options) {
+async function $do135(client, request, options) {
   const parsed = safeParse(request, (value) => ListRefundsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73736,12 +74931,12 @@ var init_transfersListRefunds = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersListRefunds.ts
-var args130, tool$transfersListRefunds;
+var args135, tool$transfersListRefunds;
 var init_transfersListRefunds2 = __esm(() => {
   init_transfersListRefunds();
   init_operations();
   init_tools();
-  args130 = {
+  args135 = {
     request: ListRefundsRequest$inboundSchema
   };
   tool$transfersListRefunds = {
@@ -73750,9 +74945,9 @@ var init_transfersListRefunds2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args130,
-    tool: async (client, args131, ctx) => {
-      const [result, apiCall] = await transfersListRefunds(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await transfersListRefunds(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73767,9 +74962,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersUpdate.ts
 function transfersUpdate(client, request, options) {
-  return new APIPromise($do131(client, request, options));
+  return new APIPromise($do136(client, request, options));
 }
-async function $do131(client, request, options) {
+async function $do136(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73852,12 +75047,12 @@ var init_transfersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersUpdate.ts
-var args131, tool$transfersUpdate;
+var args136, tool$transfersUpdate;
 var init_transfersUpdate2 = __esm(() => {
   init_transfersUpdate();
   init_operations();
   init_tools();
-  args131 = {
+  args136 = {
     request: UpdateTransferRequest$inboundSchema
   };
   tool$transfersUpdate = {
@@ -73868,9 +75063,9 @@ Read our [transfers overview guide](https://docs.moov.io/guides/money-movement/o
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args131,
-    tool: async (client, args132, ctx) => {
-      const [result, apiCall] = await transfersUpdate(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await transfersUpdate(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73885,9 +75080,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/underwritingGet.ts
 function underwritingGet(client, request, options) {
-  return new APIPromise($do132(client, request, options));
+  return new APIPromise($do137(client, request, options));
 }
-async function $do132(client, request, options) {
+async function $do137(client, request, options) {
   const parsed = safeParse(request, (value) => GetUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73965,12 +75160,12 @@ var init_underwritingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingGet.ts
-var args132, tool$underwritingGet;
+var args137, tool$underwritingGet;
 var init_underwritingGet2 = __esm(() => {
   init_underwritingGet();
   init_operations();
   init_tools();
-  args132 = {
+  args137 = {
     request: GetUnderwritingRequest$inboundSchema
   };
   tool$underwritingGet = {
@@ -73981,9 +75176,9 @@ Read our [underwriting guide](https://docs.moov.io/guides/accounts/requirements/
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
-    args: args132,
-    tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await underwritingGet(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await underwritingGet(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73998,9 +75193,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/underwritingSave.ts
 function underwritingSave(client, request, options) {
-  return new APIPromise($do133(client, request, options));
+  return new APIPromise($do138(client, request, options));
 }
-async function $do133(client, request, options) {
+async function $do138(client, request, options) {
   const parsed = safeParse(request, (value) => SaveUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74096,12 +75291,12 @@ var init_underwritingSave = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingSave.ts
-var args133, tool$underwritingSave;
+var args138, tool$underwritingSave;
 var init_underwritingSave2 = __esm(() => {
   init_underwritingSave();
   init_operations();
   init_tools();
-  args133 = {
+  args138 = {
     request: SaveUnderwritingRequest$inboundSchema
   };
   tool$underwritingSave = {
@@ -74112,9 +75307,9 @@ Read our [underwriting guide](https://docs.moov.io/guides/accounts/requirements/
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
-    args: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await underwritingSave(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args138,
+    tool: async (client, args139, ctx) => {
+      const [result, apiCall] = await underwritingSave(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74129,9 +75324,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/underwritingUpsert.ts
 function underwritingUpsert(client, request, options) {
-  return new APIPromise($do134(client, request, options));
+  return new APIPromise($do139(client, request, options));
 }
-async function $do134(client, request, options) {
+async function $do139(client, request, options) {
   const parsed = safeParse(request, (value) => UpsertUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74227,12 +75422,12 @@ var init_underwritingUpsert = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingUpsert.ts
-var args134, tool$underwritingUpsert;
+var args139, tool$underwritingUpsert;
 var init_underwritingUpsert2 = __esm(() => {
   init_underwritingUpsert();
   init_operations();
   init_tools();
-  args134 = {
+  args139 = {
     request: UpsertUnderwritingRequest$inboundSchema
   };
   tool$underwritingUpsert = {
@@ -74243,9 +75438,9 @@ Read our [underwriting guide](https://docs.moov.io/guides/accounts/requirements/
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
-    args: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await underwritingUpsert(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args139,
+    tool: async (client, args140, ctx) => {
+      const [result, apiCall] = await underwritingUpsert(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74260,9 +75455,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/walletsGet.ts
 function walletsGet(client, request, options) {
-  return new APIPromise($do135(client, request, options));
+  return new APIPromise($do140(client, request, options));
 }
-async function $do135(client, request, options) {
+async function $do140(client, request, options) {
   const parsed = safeParse(request, (value) => GetWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74344,12 +75539,12 @@ var init_walletsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsGet.ts
-var args135, tool$walletsGet;
+var args140, tool$walletsGet;
 var init_walletsGet2 = __esm(() => {
   init_walletsGet();
   init_operations();
   init_tools();
-  args135 = {
+  args140 = {
     request: GetWalletRequest$inboundSchema
   };
   tool$walletsGet = {
@@ -74360,9 +75555,9 @@ Read our [Moov wallets guide](https://docs.moov.io/guides/sources/wallets/) to l
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
-    args: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await walletsGet(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args140,
+    tool: async (client, args141, ctx) => {
+      const [result, apiCall] = await walletsGet(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74377,9 +75572,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsList.ts
 function walletsList(client, request, options) {
-  return new APIPromise($do136(client, request, options));
+  return new APIPromise($do141(client, request, options));
 }
-async function $do136(client, request, options) {
+async function $do141(client, request, options) {
   const parsed = safeParse(request, (value) => ListWalletsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74457,12 +75652,12 @@ var init_walletsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsList.ts
-var args136, tool$walletsList;
+var args141, tool$walletsList;
 var init_walletsList2 = __esm(() => {
   init_walletsList();
   init_operations();
   init_tools();
-  args136 = {
+  args141 = {
     request: ListWalletsRequest$inboundSchema
   };
   tool$walletsList = {
@@ -74473,9 +75668,9 @@ Read our [Moov wallets guide](https://docs.moov.io/guides/sources/wallets/) to l
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
-    args: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await walletsList(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args141,
+    tool: async (client, args142, ctx) => {
+      const [result, apiCall] = await walletsList(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74490,9 +75685,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletTransactionsGet.ts
 function walletTransactionsGet(client, request, options) {
-  return new APIPromise($do137(client, request, options));
+  return new APIPromise($do142(client, request, options));
 }
-async function $do137(client, request, options) {
+async function $do142(client, request, options) {
   const parsed = safeParse(request, (value) => GetWalletTransactionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74578,12 +75773,12 @@ var init_walletTransactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsGet.ts
-var args137, tool$walletTransactionsGet;
+var args142, tool$walletTransactionsGet;
 var init_walletTransactionsGet2 = __esm(() => {
   init_walletTransactionsGet();
   init_operations();
   init_tools();
-  args137 = {
+  args142 = {
     request: GetWalletTransactionRequest$inboundSchema
   };
   tool$walletTransactionsGet = {
@@ -74594,9 +75789,9 @@ Read our [wallet transactions guide](https://docs.moov.io/guides/sources/wallets
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
-    args: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await walletTransactionsGet(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args142,
+    tool: async (client, args143, ctx) => {
+      const [result, apiCall] = await walletTransactionsGet(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74611,9 +75806,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletTransactionsList.ts
 function walletTransactionsList(client, request, options) {
-  return new APIPromise($do138(client, request, options));
+  return new APIPromise($do143(client, request, options));
 }
-async function $do138(client, request, options) {
+async function $do143(client, request, options) {
   const parsed = safeParse(request, (value) => ListWalletTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74710,12 +75905,12 @@ var init_walletTransactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsList.ts
-var args138, tool$walletTransactionsList;
+var args143, tool$walletTransactionsList;
 var init_walletTransactionsList2 = __esm(() => {
   init_walletTransactionsList();
   init_operations();
   init_tools();
-  args138 = {
+  args143 = {
     request: ListWalletTransactionsRequest$inboundSchema
   };
   tool$walletTransactionsList = {
@@ -74726,9 +75921,9 @@ Read our [wallet transactions guide](https://docs.moov.io/guides/sources/wallets
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
-    args: args138,
-    tool: async (client, args139, ctx) => {
-      const [result, apiCall] = await walletTransactionsList(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args143,
+    tool: async (client, args144, ctx) => {
+      const [result, apiCall] = await walletTransactionsList(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74745,7 +75940,7 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Moov",
-    version: "0.14.0"
+    version: "0.14.1"
   });
   const client = new MoovCore({
     security: deps.security,
@@ -74848,6 +76043,11 @@ function createMCPServer(deps) {
   tool(tool$accountTerminalApplicationsList);
   tool(tool$accountTerminalApplicationsGet);
   tool(tool$accountTerminalApplicationsGetConfiguration);
+  tool(tool$supportCreateTicket);
+  tool(tool$supportListTickets);
+  tool(tool$supportGetTicket);
+  tool(tool$supportUpdateTicket);
+  tool(tool$supportListTicketMessages);
   tool(tool$transfersGenerateOptionsForAccount);
   tool(tool$transfersCreate);
   tool(tool$transfersList);
@@ -75014,6 +76214,11 @@ var init_server2 = __esm(() => {
   init_schedulingGetOccurrance2();
   init_schedulingList2();
   init_schedulingUpdate2();
+  init_supportCreateTicket2();
+  init_supportGetTicket2();
+  init_supportListTicketMessages2();
+  init_supportListTickets2();
+  init_supportUpdateTicket2();
   init_sweepsCreateConfig2();
   init_sweepsGet2();
   init_sweepsGetConfig2();
@@ -75071,7 +76276,6 @@ async function startStdio(flags) {
   const server = createMCPServer({
     logger,
     allowedTools: flags.tool,
-    scopes: flags.scope,
     security: allRequired({
       username: flags.username ?? "",
       password: flags.password ?? ""
@@ -75094,7 +76298,6 @@ async function startSSE(flags) {
   const mcpServer = createMCPServer({
     logger,
     allowedTools: flags.tool,
-    scopes: flags.scope,
     security: allRequired({
       username: flags.username ?? "",
       password: flags.password ?? ""
@@ -76136,11 +77339,6 @@ function buildContext(process2) {
 // src/mcp-server/cli/start/command.ts
 init_esm();
 init_console_logger();
-
-// src/mcp-server/scopes.ts
-var mcpScopes = [];
-
-// src/mcp-server/cli/start/command.ts
 var startCommand = tn({
   loader: async () => {
     const { main: main2 } = await Promise.resolve().then(() => (init_impl(), exports_impl));
@@ -76169,15 +77367,6 @@ var startCommand = tn({
           return stringType().parse(value);
         }
       },
-      ...mcpScopes.length ? {
-        scope: {
-          kind: "enum",
-          brief: "Mount tools/resources that match given scope (repeatable flag)",
-          values: mcpScopes,
-          variadic: true,
-          optional: true
-        }
-      } : {},
       username: {
         kind: "parsed",
         brief: "Sets the username auth field for the API",
@@ -76261,7 +77450,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.14.0"
+    currentVersion: "0.14.1"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -76269,5 +77458,5 @@ export {
   app
 };
 
-//# debugId=8B6D282DBF3AE5AB64756E2164756E21
+//# debugId=19095CB8C9F07EAB64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map