@moovio/sdk 26.4.0-dev.10 → 26.4.0-dev.11

package/bin/mcp-server.js

@@ -52879,17 +52879,18 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "v2026.04.00",
-    sdkVersion: "26.4.0-dev.10",
-    genVersion: "2.856.1",
-    userAgent: "speakeasy-sdk/typescript 26.4.0-dev.10 2.856.1 v2026.04.00 @moovio/sdk"
+    sdkVersion: "26.4.0-dev.11",
+    genVersion: "2.859.2",
+    userAgent: "speakeasy-sdk/typescript 26.4.0-dev.11 2.859.2 v2026.04.00 @moovio/sdk"
   };
 });
 
 // src/hooks/moov-version-hook.ts
 class MoovVersionHook {
-  sdkInit(opts) {
-    opts.xMoovVersion = SDK_METADATA.openapiDocVersion;
-    return opts;
+  beforeRequest(_hookCtx, request) {
+    const newRequest = new Request(request);
+    newRequest.headers.set("X-Moov-Version", SDK_METADATA.openapiDocVersion);
+    return newRequest;
   }
 }
 var init_moov_version_hook = __esm(() => {
@@ -52899,7 +52900,7 @@ var init_moov_version_hook = __esm(() => {
 // src/hooks/registration.ts
 function initHooks(hooks) {
   const versionHook = new MoovVersionHook;
-  hooks.registerSDKInitHook(versionHook);
+  hooks.registerBeforeRequestHook(versionHook);
 }
 var init_registration = __esm(() => {
   init_moov_version_hook();
@@ -62345,6 +62346,34 @@ var init_createrepresentative = __esm(() => {
   });
 });
 
+// src/models/components/resolutionlinkrecipient.ts
+var ResolutionLinkRecipient$inboundSchema, ResolutionLinkRecipient$outboundSchema;
+var init_resolutionlinkrecipient = __esm(() => {
+  init_esm();
+  init_phonenumber();
+  ResolutionLinkRecipient$inboundSchema = objectType({
+    email: stringType().optional(),
+    phone: PhoneNumber$inboundSchema.optional()
+  });
+  ResolutionLinkRecipient$outboundSchema = objectType({
+    email: stringType().optional(),
+    phone: PhoneNumber$outboundSchema.optional()
+  });
+});
+
+// src/models/components/createresolutionlink.ts
+var CreateResolutionLink$inboundSchema, CreateResolutionLink$outboundSchema;
+var init_createresolutionlink = __esm(() => {
+  init_esm();
+  init_resolutionlinkrecipient();
+  CreateResolutionLink$inboundSchema = objectType({
+    recipient: ResolutionLinkRecipient$inboundSchema
+  });
+  CreateResolutionLink$outboundSchema = objectType({
+    recipient: ResolutionLinkRecipient$outboundSchema
+  });
+});
+
 // src/models/components/createreversal.ts
 var CreateReversal$inboundSchema, CreateReversal$outboundSchema;
 var init_createreversal = __esm(() => {
@@ -66505,6 +66534,34 @@ var init_residual = __esm(() => {
   });
 });
 
+// src/models/components/resolutionlink.ts
+var ResolutionLink$inboundSchema, ResolutionLink$outboundSchema;
+var init_resolutionlink = __esm(() => {
+  init_esm();
+  ResolutionLink$inboundSchema = objectType({
+    code: stringType(),
+    accountID: stringType(),
+    partnerAccountID: stringType(),
+    recipient: stringType(),
+    url: stringType(),
+    createdOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    updatedOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    disabledOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    expiresOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+  });
+  ResolutionLink$outboundSchema = objectType({
+    code: stringType(),
+    accountID: stringType(),
+    partnerAccountID: stringType(),
+    recipient: stringType(),
+    url: stringType(),
+    createdOn: dateType().transform((v2) => v2.toISOString()),
+    updatedOn: dateType().transform((v2) => v2.toISOString()),
+    disabledOn: dateType().transform((v2) => v2.toISOString()).optional(),
+    expiresOn: dateType().transform((v2) => v2.toISOString())
+  });
+});
+
 // src/models/components/reversedwithcancellation.ts
 var ReversedWithCancellation$inboundSchema, ReversedWithCancellation$outboundSchema;
 var init_reversedwithcancellation = __esm(() => {
@@ -69050,6 +69107,7 @@ var init_components = __esm(() => {
   init_createrefund();
   init_createrefundresponse();
   init_createrepresentative();
+  init_createresolutionlink();
   init_createreversal();
   init_createruntransfer();
   init_createscheduledtransferlineitem();
@@ -69291,6 +69349,8 @@ var init_components = __esm(() => {
   init_requirementerrorcode();
   init_requirementid();
   init_residual();
+  init_resolutionlink();
+  init_resolutionlinkrecipient();
   init_returnpolicytype();
   init_reversal();
   init_reversedwithcancellation();
@@ -69849,6 +69909,45 @@ var init_createpaymentlinkerror = __esm(() => {
   }));
 });
 
+// src/models/errors/createresolutionlinkerror.ts
+var CreateResolutionLinkError, CreateResolutionLinkError$inboundSchema, CreateResolutionLinkError$outboundSchema;
+var init_createresolutionlinkerror = __esm(() => {
+  init_esm();
+  init_mooverror();
+  CreateResolutionLinkError = class CreateResolutionLinkError extends MoovError {
+    email;
+    phone;
+    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.email != null)
+        this.email = err.email;
+      if (err.phone != null)
+        this.phone = err.phone;
+      this.name = "CreateResolutionLinkError";
+    }
+  };
+  CreateResolutionLinkError$inboundSchema = objectType({
+    email: stringType().optional(),
+    phone: stringType().optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new CreateResolutionLinkError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  CreateResolutionLinkError$outboundSchema = instanceOfType(CreateResolutionLinkError).transform((v2) => v2.data$).pipe(objectType({
+    email: stringType().optional(),
+    phone: stringType().optional()
+  }));
+});
+
 // src/models/errors/createsweepconfigerror.ts
 var CreateSweepConfigError, CreateSweepConfigError$inboundSchema, CreateSweepConfigError$outboundSchema;
 var init_createsweepconfigerror = __esm(() => {
@@ -72273,6 +72372,7 @@ var init_errors4 = __esm(() => {
   init_createinvoiceerror();
   init_createinvoicepaymenterror();
   init_createpaymentlinkerror();
+  init_createresolutionlinkerror();
   init_createsweepconfigerror();
   init_createticketerror();
   init_createwalletvalidationerror();
@@ -73294,6 +73394,62 @@ var init_createrepresentative2 = __esm(() => {
   });
 });
 
+// src/models/operations/createresolutionlink.ts
+var CreateResolutionLinkGlobals$inboundSchema, CreateResolutionLinkGlobals$outboundSchema, CreateResolutionLinkRequest$inboundSchema, CreateResolutionLinkRequest$outboundSchema, CreateResolutionLinkResponse$inboundSchema, CreateResolutionLinkResponse$outboundSchema;
+var init_createresolutionlink2 = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  CreateResolutionLinkGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  CreateResolutionLinkGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  CreateResolutionLinkRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    CreateResolutionLink: CreateResolutionLink$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      CreateResolutionLink: "createResolutionLink"
+    });
+  });
+  CreateResolutionLinkRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    createResolutionLink: CreateResolutionLink$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      createResolutionLink: "CreateResolutionLink"
+    });
+  });
+  CreateResolutionLinkResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: ResolutionLink$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  CreateResolutionLinkResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: ResolutionLink$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/createreversal.ts
 var CreateReversalGlobals$inboundSchema, CreateReversalGlobals$outboundSchema, CreateReversalRequest$inboundSchema, CreateReversalRequest$outboundSchema, CreateReversalResponse$inboundSchema, CreateReversalResponse$outboundSchema;
 var init_createreversal2 = __esm(() => {
@@ -74285,6 +74441,49 @@ var init_disableproduct = __esm(() => {
   });
 });
 
+// src/models/operations/disableresolutionlink.ts
+var DisableResolutionLinkGlobals$inboundSchema, DisableResolutionLinkGlobals$outboundSchema, DisableResolutionLinkRequest$inboundSchema, DisableResolutionLinkRequest$outboundSchema, DisableResolutionLinkResponse$inboundSchema, DisableResolutionLinkResponse$outboundSchema;
+var init_disableresolutionlink = __esm(() => {
+  init_esm();
+  init_primitives();
+  DisableResolutionLinkGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  DisableResolutionLinkGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  DisableResolutionLinkRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    resolutionLinkCode: stringType()
+  });
+  DisableResolutionLinkRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    resolutionLinkCode: stringType()
+  });
+  DisableResolutionLinkResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({})
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers"
+    });
+  });
+  DisableResolutionLinkResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType()))
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers"
+    });
+  });
+});
+
 // src/models/operations/disablewebhook.ts
 var DisableWebhookGlobals$inboundSchema, DisableWebhookGlobals$outboundSchema, DisableWebhookRequest$inboundSchema, DisableWebhookRequest$outboundSchema, DisableWebhookResponse$inboundSchema, DisableWebhookResponse$outboundSchema;
 var init_disablewebhook = __esm(() => {
@@ -76097,6 +76296,54 @@ var init_getresidual = __esm(() => {
   });
 });
 
+// src/models/operations/getresolutionlink.ts
+var GetResolutionLinkGlobals$inboundSchema, GetResolutionLinkGlobals$outboundSchema, GetResolutionLinkRequest$inboundSchema, GetResolutionLinkRequest$outboundSchema, GetResolutionLinkResponse$inboundSchema, GetResolutionLinkResponse$outboundSchema;
+var init_getresolutionlink = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  GetResolutionLinkGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  GetResolutionLinkGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  GetResolutionLinkRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    resolutionLinkCode: stringType()
+  });
+  GetResolutionLinkRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    resolutionLinkCode: stringType()
+  });
+  GetResolutionLinkResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: ResolutionLink$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  GetResolutionLinkResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: ResolutionLink$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/getscheduledoccurrence.ts
 var GetScheduledOccurrenceGlobals$inboundSchema, GetScheduledOccurrenceGlobals$outboundSchema, GetScheduledOccurrenceRequest$inboundSchema, GetScheduledOccurrenceRequest$outboundSchema, GetScheduledOccurrenceResponse$inboundSchema, GetScheduledOccurrenceResponse$outboundSchema;
 var init_getscheduledoccurrence = __esm(() => {
@@ -78996,6 +79243,52 @@ var init_listresiduals = __esm(() => {
   });
 });
 
+// src/models/operations/listresolutionlinks.ts
+var ListResolutionLinksGlobals$inboundSchema, ListResolutionLinksGlobals$outboundSchema, ListResolutionLinksRequest$inboundSchema, ListResolutionLinksRequest$outboundSchema, ListResolutionLinksResponse$inboundSchema, ListResolutionLinksResponse$outboundSchema;
+var init_listresolutionlinks = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ListResolutionLinksGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  ListResolutionLinksGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  ListResolutionLinksRequest$inboundSchema = objectType({
+    accountID: stringType()
+  });
+  ListResolutionLinksRequest$outboundSchema = objectType({
+    accountID: stringType()
+  });
+  ListResolutionLinksResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: arrayType(ResolutionLink$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ListResolutionLinksResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: arrayType(ResolutionLink$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/listschedules.ts
 var Hydrate, ListSchedulesGlobals$inboundSchema, ListSchedulesGlobals$outboundSchema, Hydrate$inboundSchema, Hydrate$outboundSchema, ListSchedulesRequest$inboundSchema, ListSchedulesRequest$outboundSchema, ListSchedulesResponse$inboundSchema, ListSchedulesResponse$outboundSchema;
 var init_listschedules = __esm(() => {
@@ -81510,6 +81803,7 @@ var init_operations = __esm(() => {
   init_createproduct();
   init_createreceipts();
   init_createrepresentative2();
+  init_createresolutionlink2();
   init_createreversal2();
   init_createschedule();
   init_createsweepconfig2();
@@ -81530,6 +81824,7 @@ var init_operations = __esm(() => {
   init_disablecard();
   init_disablepaymentlink();
   init_disableproduct();
+  init_disableresolutionlink();
   init_disablewebhook();
   init_disconnectaccount();
   init_generateendtoendkey();
@@ -81567,6 +81862,7 @@ var init_operations = __esm(() => {
   init_getrefund();
   init_getrepresentative();
   init_getresidual();
+  init_getresolutionlink();
   init_getscheduledoccurrence();
   init_getschedules();
   init_getstatement();
@@ -81623,6 +81919,7 @@ var init_operations = __esm(() => {
   init_listrepresentatives();
   init_listresidualfees();
   init_listresiduals();
+  init_listresolutionlinks();
   init_listschedules();
   init_liststatements();
   init_listsweepconfigs();
@@ -96979,29 +97276,28 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
   };
 });
 
-// src/funcs/schedulingCancel.ts
-function schedulingCancel(client, request, options) {
+// src/funcs/resolutionLinksCreate.ts
+function resolutionLinksCreate(client, request, options) {
   return new APIPromise($do127(client, request, options));
 }
 async function $do127(client, request, options) {
-  const parsed = safeParse4(request, (value) => CancelScheduleRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => CreateResolutionLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = encodeJSON("body", payload.CreateResolutionLink, {
+    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 path = pathToFunc("/accounts/{accountID}/resolution-links")(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" })
   }));
@@ -97010,7 +97306,7 @@ async function $do127(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "cancelSchedule",
+    operationID: "createResolutionLink",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -97019,7 +97315,7 @@ async function $do127(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "DELETE",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -97039,6 +97335,7 @@ async function $do127(client, request, options) {
       "403",
       "404",
       "409",
+      "422",
       "429",
       "4XX",
       "500",
@@ -97055,15 +97352,18 @@ async function $do127(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, CancelScheduleResponse$inboundSchema.optional(), {
+  const [result] = await match(json(200, CreateResolutionLinkResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, CreateResolutionLinkError$inboundSchema, {
     hdrs: true
-  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  }), 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_schedulingCancel = __esm(() => {
+var init_resolutionLinksCreate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -97075,55 +97375,58 @@ var init_schedulingCancel = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/schedulingCancel.ts
-var args127, tool$schedulingCancel;
-var init_schedulingCancel2 = __esm(() => {
-  init_schedulingCancel();
+// src/mcp-server/tools/resolutionLinksCreate.ts
+var args127, tool$resolutionLinksCreate;
+var init_resolutionLinksCreate2 = __esm(() => {
+  init_resolutionLinksCreate();
   init_operations();
   init_tools();
   args127 = {
-    request: CancelScheduleRequest$inboundSchema
+    request: CreateResolutionLinkRequest$inboundSchema
   };
-  tool$schedulingCancel = {
-    name: "scheduling-cancel",
-    description: `Describes the schedule to cancel.
+  tool$resolutionLinksCreate = {
+    name: "resolution-links-create",
+    description: `Create a resolution link for the specified account. Resolution links are temporary, secure links
+sent to merchants to resolve account requirements such as KYC verification or document uploads.  Only one active resolution link
+is allowed per connected 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.write\` scope.`,
+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\`, \`/accounts/{accountID}/representatives.write\` and \`/accounts/{accountID}/files.write\` scopes.`,
     args: args127,
     tool: async (client, args128, ctx) => {
-      const [result, apiCall] = await schedulingCancel(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await resolutionLinksCreate(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      return formatResult(undefined, apiCall);
+      const value = result.value.result;
+      return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/schedulingCreate.ts
-function schedulingCreate(client, request, options) {
+// src/funcs/resolutionLinksDisable.ts
+function resolutionLinksDisable(client, request, options) {
   return new APIPromise($do128(client, request, options));
 }
 async function $do128(client, request, options) {
-  const parsed = safeParse4(request, (value) => CreateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => DisableResolutionLinkRequest$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 = null;
   const pathParams = {
     accountID: encodeSimple("accountID", payload.accountID, {
       explode: false,
       charEncoding: "percent"
-    })
+    }),
+    resolutionLinkCode: encodeSimple("resolutionLinkCode", payload.resolutionLinkCode, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/accounts/{accountID}/schedules")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/resolution-links/{resolutionLinkCode}")(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" })
   }));
@@ -97132,7 +97435,7 @@ async function $do128(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "createSchedule",
+    operationID: "disableResolutionLink",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -97141,7 +97444,7 @@ async function $do128(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "DELETE",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -97161,7 +97464,6 @@ async function $do128(client, request, options) {
       "403",
       "404",
       "409",
-      "422",
       "429",
       "4XX",
       "500",
@@ -97178,18 +97480,13 @@ async function $do128(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  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 });
+  const [result] = await match(nil(204, DisableResolutionLinkResponse$inboundSchema.optional(), { hdrs: true }), jsonErr([400, 409], GenericError$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(() => {
+var init_resolutionLinksDisable = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -97201,42 +97498,41 @@ var init_schedulingCreate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/schedulingCreate.ts
-var args128, tool$schedulingCreate;
-var init_schedulingCreate2 = __esm(() => {
-  init_schedulingCreate();
+// src/mcp-server/tools/resolutionLinksDisable.ts
+var args128, tool$resolutionLinksDisable;
+var init_resolutionLinksDisable2 = __esm(() => {
+  init_resolutionLinksDisable();
   init_operations();
   init_tools();
   args128 = {
-    request: CreateScheduleRequest$inboundSchema
+    request: DisableResolutionLinkRequest$inboundSchema
   };
-  tool$schedulingCreate = {
-    name: "scheduling-create",
-    description: `Describes the schedule to create or modify.
+  tool$resolutionLinksDisable = {
+    name: "resolution-links-disable",
+    description: `Disable a resolution link. Disabled resolution links can no longer be used by merchants.
 
-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.`,
+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: args128,
     tool: async (client, args129, ctx) => {
-      const [result, apiCall] = await schedulingCreate(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await resolutionLinksDisable(client, args129.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);
+      return formatResult(undefined, apiCall);
     }
   };
 });
 
-// src/funcs/schedulingGet.ts
-function schedulingGet(client, request, options) {
+// src/funcs/resolutionLinksGet.ts
+function resolutionLinksGet(client, request, options) {
   return new APIPromise($do129(client, request, options));
 }
 async function $do129(client, request, options) {
-  const parsed = safeParse4(request, (value) => GetSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => GetResolutionLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -97247,12 +97543,9 @@ async function $do129(client, request, options) {
       explode: false,
       charEncoding: "percent"
     }),
-    scheduleID: encodeSimple("scheduleID", payload.scheduleID, {
-      explode: false,
-      charEncoding: "percent"
-    })
+    resolutionLinkCode: encodeSimple("resolutionLinkCode", payload.resolutionLinkCode, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/accounts/{accountID}/schedules/{scheduleID}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/resolution-links/{resolutionLinkCode}")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "X-Moov-Version": encodeSimple("X-Moov-Version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
@@ -97262,7 +97555,485 @@ async function $do129(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getSchedules",
+    operationID: "getResolutionLink",
+    oAuth2Scopes: null,
+    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, GetResolutionLinkResponse$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_resolutionLinksGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/resolutionLinksGet.ts
+var args129, tool$resolutionLinksGet;
+var init_resolutionLinksGet2 = __esm(() => {
+  init_resolutionLinksGet();
+  init_operations();
+  init_tools();
+  args129 = {
+    request: GetResolutionLinkRequest$inboundSchema
+  };
+  tool$resolutionLinksGet = {
+    name: "resolution-links-get",
+    description: `Get a resolution link by code.
+
+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: args129,
+    tool: async (client, args130, ctx) => {
+      const [result, apiCall] = await resolutionLinksGet(client, args130.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/resolutionLinksList.ts
+function resolutionLinksList(client, request, options) {
+  return new APIPromise($do130(client, request, options));
+}
+async function $do130(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListResolutionLinksRequest$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}/resolution-links")(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: "listResolutionLinks",
+    oAuth2Scopes: null,
+    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", "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, ListResolutionLinksResponse$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_resolutionLinksList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/resolutionLinksList.ts
+var args130, tool$resolutionLinksList;
+var init_resolutionLinksList2 = __esm(() => {
+  init_resolutionLinksList();
+  init_operations();
+  init_tools();
+  args130 = {
+    request: ListResolutionLinksRequest$inboundSchema
+  };
+  tool$resolutionLinksList = {
+    name: "resolution-links-list",
+    description: `List resolution links for the specified 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}/profile.read\` scope.`,
+    args: args130,
+    tool: async (client, args131, ctx) => {
+      const [result, apiCall] = await resolutionLinksList(client, args131.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/schedulingCancel.ts
+function schedulingCancel(client, request, options) {
+  return new APIPromise($do131(client, request, options));
+}
+async function $do131(client, request, options) {
+  const parsed = safeParse4(request, (value) => CancelScheduleRequest$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: "cancelSchedule",
+    oAuth2Scopes: null,
+    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: "DELETE",
+    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",
+      "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(nil(204, CancelScheduleResponse$inboundSchema.optional(), {
+    hdrs: true
+  }), jsonErr([400, 409], GenericError$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_schedulingCancel = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/schedulingCancel.ts
+var args131, tool$schedulingCancel;
+var init_schedulingCancel2 = __esm(() => {
+  init_schedulingCancel();
+  init_operations();
+  init_tools();
+  args131 = {
+    request: CancelScheduleRequest$inboundSchema
+  };
+  tool$schedulingCancel = {
+    name: "scheduling-cancel",
+    description: `Describes the schedule to cancel.
+
+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 schedulingCancel(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      return formatResult(undefined, apiCall);
+    }
+  };
+});
+
+// src/funcs/schedulingCreate.ts
+function schedulingCreate(client, request, options) {
+  return new APIPromise($do132(client, request, options));
+}
+async function $do132(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateScheduleRequest$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"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/schedules")(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: "createSchedule",
+    oAuth2Scopes: null,
+    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, 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_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/schedulingCreate.ts
+var args132, tool$schedulingCreate;
+var init_schedulingCreate2 = __esm(() => {
+  init_schedulingCreate();
+  init_operations();
+  init_tools();
+  args132 = {
+    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: args132,
+    tool: async (client, args133, ctx) => {
+      const [result, apiCall] = await schedulingCreate(client, args133.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($do133(client, request, options));
+}
+async function $do133(client, request, options) {
+  const parsed = safeParse4(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: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -97317,12 +98088,12 @@ var init_schedulingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingGet.ts
-var args129, tool$schedulingGet;
+var args133, tool$schedulingGet;
 var init_schedulingGet2 = __esm(() => {
   init_schedulingGet();
   init_operations();
   init_tools();
-  args129 = {
+  args133 = {
     request: GetSchedulesRequest$inboundSchema
   };
   tool$schedulingGet = {
@@ -97331,9 +98102,9 @@ var init_schedulingGet2 = __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: args129,
-    tool: async (client, args130, ctx) => {
-      const [result, apiCall] = await schedulingGet(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await schedulingGet(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97348,9 +98119,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingGetOccurrance.ts
 function schedulingGetOccurrance(client, request, options) {
-  return new APIPromise($do130(client, request, options));
+  return new APIPromise($do134(client, request, options));
 }
-async function $do130(client, request, options) {
+async function $do134(client, request, options) {
   const parsed = safeParse4(request, (value) => GetScheduledOccurrenceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97433,12 +98204,12 @@ var init_schedulingGetOccurrance = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingGetOccurrance.ts
-var args130, tool$schedulingGetOccurrance;
+var args134, tool$schedulingGetOccurrance;
 var init_schedulingGetOccurrance2 = __esm(() => {
   init_schedulingGetOccurrance();
   init_operations();
   init_tools();
-  args130 = {
+  args134 = {
     request: GetScheduledOccurrenceRequest$inboundSchema
   };
   tool$schedulingGetOccurrance = {
@@ -97447,9 +98218,9 @@ var init_schedulingGetOccurrance2 = __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 schedulingGetOccurrance(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await schedulingGetOccurrance(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97464,9 +98235,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingList.ts
 function schedulingList(client, request, options) {
-  return new APIPromise($do131(client, request, options));
+  return new APIPromise($do135(client, request, options));
 }
-async function $do131(client, request, options) {
+async function $do135(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97550,12 +98321,12 @@ var init_schedulingList = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingList.ts
-var args131, tool$schedulingList;
+var args135, tool$schedulingList;
 var init_schedulingList2 = __esm(() => {
   init_schedulingList();
   init_operations();
   init_tools();
-  args131 = {
+  args135 = {
     request: ListSchedulesRequest$inboundSchema
   };
   tool$schedulingList = {
@@ -97564,9 +98335,9 @@ var init_schedulingList2 = __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: args131,
-    tool: async (client, args132, ctx) => {
-      const [result, apiCall] = await schedulingList(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await schedulingList(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97581,9 +98352,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingUpdate.ts
 function schedulingUpdate(client, request, options) {
-  return new APIPromise($do132(client, request, options));
+  return new APIPromise($do136(client, request, options));
 }
-async function $do132(client, request, options) {
+async function $do136(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97681,12 +98452,12 @@ var init_schedulingUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingUpdate.ts
-var args132, tool$schedulingUpdate;
+var args136, tool$schedulingUpdate;
 var init_schedulingUpdate2 = __esm(() => {
   init_schedulingUpdate();
   init_operations();
   init_tools();
-  args132 = {
+  args136 = {
     request: UpdateScheduleRequest$inboundSchema
   };
   tool$schedulingUpdate = {
@@ -97695,9 +98466,9 @@ var init_schedulingUpdate2 = __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.write\` scope.`,
-    args: args132,
-    tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await schedulingUpdate(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await schedulingUpdate(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97712,9 +98483,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/statementsGet.ts
 function statementsGet(client, request, options) {
-  return new APIPromise($do133(client, request, options));
+  return new APIPromise($do137(client, request, options));
 }
-async function $do133(client, request, options) {
+async function $do137(client, request, options) {
   const parsed = safeParse4(request, (value) => GetStatementRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97800,12 +98571,12 @@ var init_statementsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/statementsGet.ts
-var args133, tool$statementsGet;
+var args137, tool$statementsGet;
 var init_statementsGet2 = __esm(() => {
   init_statementsGet();
   init_operations();
   init_tools();
-  args133 = {
+  args137 = {
     request: GetStatementRequest$inboundSchema
   };
   tool$statementsGet = {
@@ -97816,9 +98587,9 @@ Use the \`Accept\` header to specify the format of the response. Supported forma
 
 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: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await statementsGet(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await statementsGet(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97833,9 +98604,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/statementsList.ts
 function statementsList(client, request, options) {
-  return new APIPromise($do134(client, request, options));
+  return new APIPromise($do138(client, request, options));
 }
-async function $do134(client, request, options) {
+async function $do138(client, request, options) {
   const parsed = safeParse4(request, (value) => ListStatementsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97921,12 +98692,12 @@ var init_statementsList = __esm(() => {
 });
 
 // src/mcp-server/tools/statementsList.ts
-var args134, tool$statementsList;
+var args138, tool$statementsList;
 var init_statementsList2 = __esm(() => {
   init_statementsList();
   init_operations();
   init_tools();
-  args134 = {
+  args138 = {
     request: ListStatementsRequest$inboundSchema
   };
   tool$statementsList = {
@@ -97935,9 +98706,9 @@ var init_statementsList2 = __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}/profile.read\` scope.`,
-    args: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await statementsList(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args138,
+    tool: async (client, args139, ctx) => {
+      const [result, apiCall] = await statementsList(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97952,9 +98723,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/supportCreateTicket.ts
 function supportCreateTicket(client, request, options) {
-  return new APIPromise($do135(client, request, options));
+  return new APIPromise($do139(client, request, options));
 }
-async function $do135(client, request, options) {
+async function $do139(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -98046,12 +98817,12 @@ var init_supportCreateTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportCreateTicket.ts
-var args135, tool$supportCreateTicket;
+var args139, tool$supportCreateTicket;
 var init_supportCreateTicket2 = __esm(() => {
   init_supportCreateTicket();
   init_operations();
   init_tools();
-  args135 = {
+  args139 = {
     request: CreateTicketRequest$inboundSchema
   };
   tool$supportCreateTicket = {
@@ -98063,9 +98834,9 @@ you'll need to specify the \`/accounts/{accountID}/tickets.write\` scope.
 
 If you're creating the ticket on behalf of another account, then you'll need to
 specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{accountID}/profile.read\` scopes.`,
-    args: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await supportCreateTicket(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args139,
+    tool: async (client, args140, ctx) => {
+      const [result, apiCall] = await supportCreateTicket(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -98080,9 +98851,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{acco
 
 // src/funcs/supportGetTicket.ts
 function supportGetTicket(client, request, options) {
-  return new APIPromise($do136(client, request, options));
+  return new APIPromise($do140(client, request, options));
 }
-async function $do136(client, request, options) {
+async function $do140(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -98164,12 +98935,12 @@ var init_supportGetTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportGetTicket.ts
-var args136, tool$supportGetTicket;
+var args140, tool$supportGetTicket;
 var init_supportGetTicket2 = __esm(() => {
   init_supportGetTicket();
   init_operations();
   init_tools();
-  args136 = {
+  args140 = {
     request: GetTicketRequest$inboundSchema
   };
   tool$supportGetTicket = {
@@ -98181,9 +98952,9 @@ you'll need to specify the \`/accounts/{accountID}/tickets.read\` scope.
 
 If you're retrieving another account's ticket, then you'll need to
 specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accountID}/profile.read\` scopes.`,
-    args: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await supportGetTicket(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args140,
+    tool: async (client, args141, ctx) => {
+      const [result, apiCall] = await supportGetTicket(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -98198,9 +98969,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportListTicketMessages.ts
 function supportListTicketMessages(client, request, options) {
-  return new APIPromise($do137(client, request, options));
+  return new APIPromise($do141(client, request, options));
 }
-async function $do137(client, request, options) {
+async function $do141(client, request, options) {
   const parsed = safeParse4(request, (value) => ListTicketMessagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -98282,12 +99053,12 @@ var init_supportListTicketMessages = __esm(() => {
 });
 
 // src/mcp-server/tools/supportListTicketMessages.ts
-var args137, tool$supportListTicketMessages;
+var args141, tool$supportListTicketMessages;
 var init_supportListTicketMessages2 = __esm(() => {
   init_supportListTicketMessages();
   init_operations();
   init_tools();
-  args137 = {
+  args141 = {
     request: ListTicketMessagesRequest$inboundSchema
   };
   tool$supportListTicketMessages = {
@@ -98299,9 +99070,9 @@ you'll need to specify the \`/accounts/{accountID}/tickets.read\` scope.
 
 If you're listing another account's messages, then you'll need to
 specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accountID}/profile.read\` scopes.`,
-    args: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await supportListTicketMessages(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args141,
+    tool: async (client, args142, ctx) => {
+      const [result, apiCall] = await supportListTicketMessages(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -98316,9 +99087,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportListTickets.ts
 function supportListTickets(client, request, options) {
-  return new APIPromise($do138(client, request, options));
+  return new APIPromise($do142(client, request, options));
 }
-async function $do138(client, request, options) {
+async function $do142(client, request, options) {
   const parsed = safeParse4(request, (value) => ListTicketsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -98403,12 +99174,12 @@ var init_supportListTickets = __esm(() => {
 });
 
 // src/mcp-server/tools/supportListTickets.ts
-var args138, tool$supportListTickets;
+var args142, tool$supportListTickets;
 var init_supportListTickets2 = __esm(() => {
   init_supportListTickets();
   init_operations();
   init_tools();
-  args138 = {
+  args142 = {
     request: ListTicketsRequest$inboundSchema
   };
   tool$supportListTickets = {
@@ -98420,9 +99191,9 @@ you'll need to specify the \`/accounts/{accountID}/tickets.read\` scope.
 
 If you're listing another account's tickets, then you'll need to
 specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accountID}/profile.read\` scopes.`,
-    args: args138,
-    tool: async (client, args139, ctx) => {
-      const [result, apiCall] = await supportListTickets(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args142,
+    tool: async (client, args143, ctx) => {
+      const [result, apiCall] = await supportListTickets(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -98437,9 +99208,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportUpdateTicket.ts
 function supportUpdateTicket(client, request, options) {
-  return new APIPromise($do139(client, request, options));
+  return new APIPromise($do143(client, request, options));
 }
-async function $do139(client, request, options) {
+async function $do143(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -98535,12 +99306,12 @@ var init_supportUpdateTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportUpdateTicket.ts
-var args139, tool$supportUpdateTicket;
+var args143, tool$supportUpdateTicket;
 var init_supportUpdateTicket2 = __esm(() => {
   init_supportUpdateTicket();
   init_operations();
   init_tools();
-  args139 = {
+  args143 = {
     request: UpdateTicketRequest$inboundSchema
   };
   tool$supportUpdateTicket = {
@@ -98552,9 +99323,9 @@ you'll need to specify the \`/accounts/{accountID}/tickets.write\` scope.
 
 If you're updating the ticket on behalf of another account, then you'll need to
 specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{accountID}/profile.read\` scopes.`,
-    args: args139,
-    tool: async (client, args140, ctx) => {
-      const [result, apiCall] = await supportUpdateTicket(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args143,
+    tool: async (client, args144, ctx) => {
+      const [result, apiCall] = await supportUpdateTicket(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -98569,9 +99340,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{acco
 
 // src/funcs/sweepsCreateConfig.ts
 function sweepsCreateConfig(client, request, options) {
-  return new APIPromise($do140(client, request, options));
+  return new APIPromise($do144(client, request, options));
 }
-async function $do140(client, request, options) {
+async function $do144(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -98663,12 +99434,12 @@ var init_sweepsCreateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsCreateConfig.ts
-var args140, tool$sweepsCreateConfig;
+var args144, tool$sweepsCreateConfig;
 var init_sweepsCreateConfig2 = __esm(() => {
   init_sweepsCreateConfig();
   init_operations();
   init_tools();
-  args140 = {
+  args144 = {
     request: CreateSweepConfigRequest$inboundSchema
   };
   tool$sweepsCreateConfig = {
@@ -98677,9 +99448,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: args140,
-    tool: async (client, args141, ctx) => {
-      const [result, apiCall] = await sweepsCreateConfig(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args144,
+    tool: async (client, args145, ctx) => {
+      const [result, apiCall] = await sweepsCreateConfig(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -98694,9 +99465,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/sweepsGet.ts
 function sweepsGet(client, request, options) {
-  return new APIPromise($do141(client, request, options));
+  return new APIPromise($do145(client, request, options));
 }
-async function $do141(client, request, options) {
+async function $do145(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSweepRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -98782,12 +99553,12 @@ var init_sweepsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGet.ts
-var args141, tool$sweepsGet;
+var args145, tool$sweepsGet;
 var init_sweepsGet2 = __esm(() => {
   init_sweepsGet();
   init_operations();
   init_tools();
-  args141 = {
+  args145 = {
     request: GetSweepRequest$inboundSchema
   };
   tool$sweepsGet = {
@@ -98796,9 +99567,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: args141,
-    tool: async (client, args142, ctx) => {
-      const [result, apiCall] = await sweepsGet(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args145,
+    tool: async (client, args146, ctx) => {
+      const [result, apiCall] = await sweepsGet(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -98813,9 +99584,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsGetConfig.ts
 function sweepsGetConfig(client, request, options) {
-  return new APIPromise($do142(client, request, options));
+  return new APIPromise($do146(client, request, options));
 }
-async function $do142(client, request, options) {
+async function $do146(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -98897,12 +99668,12 @@ var init_sweepsGetConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGetConfig.ts
-var args142, tool$sweepsGetConfig;
+var args146, tool$sweepsGetConfig;
 var init_sweepsGetConfig2 = __esm(() => {
   init_sweepsGetConfig();
   init_operations();
   init_tools();
-  args142 = {
+  args146 = {
     request: GetSweepConfigRequest$inboundSchema
   };
   tool$sweepsGetConfig = {
@@ -98911,9 +99682,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: args142,
-    tool: async (client, args143, ctx) => {
-      const [result, apiCall] = await sweepsGetConfig(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args146,
+    tool: async (client, args147, ctx) => {
+      const [result, apiCall] = await sweepsGetConfig(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -98928,9 +99699,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsList.ts
 function sweepsList(client, request, options) {
-  return new APIPromise($do143(client, request, options));
+  return new APIPromise($do147(client, request, options));
 }
-async function $do143(client, request, options) {
+async function $do147(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSweepsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -99019,12 +99790,12 @@ var init_sweepsList = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsList.ts
-var args143, tool$sweepsList;
+var args147, tool$sweepsList;
 var init_sweepsList2 = __esm(() => {
   init_sweepsList();
   init_operations();
   init_tools();
-  args143 = {
+  args147 = {
     request: ListSweepsRequest$inboundSchema
   };
   tool$sweepsList = {
@@ -99033,9 +99804,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: args143,
-    tool: async (client, args144, ctx) => {
-      const [result, apiCall] = await sweepsList(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args147,
+    tool: async (client, args148, ctx) => {
+      const [result, apiCall] = await sweepsList(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99050,9 +99821,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsListConfigs.ts
 function sweepsListConfigs(client, request, options) {
-  return new APIPromise($do144(client, request, options));
+  return new APIPromise($do148(client, request, options));
 }
-async function $do144(client, request, options) {
+async function $do148(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSweepConfigsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -99130,12 +99901,12 @@ var init_sweepsListConfigs = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsListConfigs.ts
-var args144, tool$sweepsListConfigs;
+var args148, tool$sweepsListConfigs;
 var init_sweepsListConfigs2 = __esm(() => {
   init_sweepsListConfigs();
   init_operations();
   init_tools();
-  args144 = {
+  args148 = {
     request: ListSweepConfigsRequest$inboundSchema
   };
   tool$sweepsListConfigs = {
@@ -99144,9 +99915,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: args144,
-    tool: async (client, args145, ctx) => {
-      const [result, apiCall] = await sweepsListConfigs(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args148,
+    tool: async (client, args149, ctx) => {
+      const [result, apiCall] = await sweepsListConfigs(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99161,9 +99932,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsUpdateConfig.ts
 function sweepsUpdateConfig(client, request, options) {
-  return new APIPromise($do145(client, request, options));
+  return new APIPromise($do149(client, request, options));
 }
-async function $do145(client, request, options) {
+async function $do149(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -99259,12 +100030,12 @@ var init_sweepsUpdateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsUpdateConfig.ts
-var args145, tool$sweepsUpdateConfig;
+var args149, tool$sweepsUpdateConfig;
 var init_sweepsUpdateConfig2 = __esm(() => {
   init_sweepsUpdateConfig();
   init_operations();
   init_tools();
-  args145 = {
+  args149 = {
     request: UpdateSweepConfigRequest$inboundSchema
   };
   tool$sweepsUpdateConfig = {
@@ -99273,9 +100044,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: args145,
-    tool: async (client, args146, ctx) => {
-      const [result, apiCall] = await sweepsUpdateConfig(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args149,
+    tool: async (client, args150, ctx) => {
+      const [result, apiCall] = await sweepsUpdateConfig(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99290,9 +100061,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreate.ts
 function terminalApplicationsCreate(client, request, options) {
-  return new APIPromise($do146(client, request, options));
+  return new APIPromise($do150(client, request, options));
 }
-async function $do146(client, request, options) {
+async function $do150(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateTerminalApplication$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -99381,12 +100152,12 @@ var init_terminalApplicationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreate.ts
-var args146, tool$terminalApplicationsCreate;
+var args150, tool$terminalApplicationsCreate;
 var init_terminalApplicationsCreate2 = __esm(() => {
   init_terminalApplicationsCreate();
   init_components();
   init_tools();
-  args146 = {
+  args150 = {
     request: CreateTerminalApplication$inboundSchema
   };
   tool$terminalApplicationsCreate = {
@@ -99395,9 +100166,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: args146,
-    tool: async (client, args147, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreate(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args150,
+    tool: async (client, args151, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreate(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99412,9 +100183,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreateVersion.ts
 function terminalApplicationsCreateVersion(client, request, options) {
-  return new APIPromise($do147(client, request, options));
+  return new APIPromise($do151(client, request, options));
 }
-async function $do147(client, request, options) {
+async function $do151(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateTerminalApplicationVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -99504,12 +100275,12 @@ var init_terminalApplicationsCreateVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreateVersion.ts
-var args147, tool$terminalApplicationsCreateVersion;
+var args151, tool$terminalApplicationsCreateVersion;
 var init_terminalApplicationsCreateVersion2 = __esm(() => {
   init_terminalApplicationsCreateVersion();
   init_operations();
   init_tools();
-  args147 = {
+  args151 = {
     request: CreateTerminalApplicationVersionRequest$inboundSchema
   };
   tool$terminalApplicationsCreateVersion = {
@@ -99518,9 +100289,9 @@ var init_terminalApplicationsCreateVersion2 = __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: args147,
-    tool: async (client, args148, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args151,
+    tool: async (client, args152, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99535,9 +100306,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsDelete.ts
 function terminalApplicationsDelete(client, request, options) {
-  return new APIPromise($do148(client, request, options));
+  return new APIPromise($do152(client, request, options));
 }
-async function $do148(client, request, options) {
+async function $do152(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -99621,12 +100392,12 @@ var init_terminalApplicationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsDelete.ts
-var args148, tool$terminalApplicationsDelete;
+var args152, tool$terminalApplicationsDelete;
 var init_terminalApplicationsDelete2 = __esm(() => {
   init_terminalApplicationsDelete();
   init_operations();
   init_tools();
-  args148 = {
+  args152 = {
     request: DeleteTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsDelete = {
@@ -99635,9 +100406,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: args148,
-    tool: async (client, args149, ctx) => {
-      const [result, apiCall] = await terminalApplicationsDelete(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args152,
+    tool: async (client, args153, ctx) => {
+      const [result, apiCall] = await terminalApplicationsDelete(client, args153.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99651,9 +100422,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsGet.ts
 function terminalApplicationsGet(client, request, options) {
-  return new APIPromise($do149(client, request, options));
+  return new APIPromise($do153(client, request, options));
 }
-async function $do149(client, request, options) {
+async function $do153(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -99728,12 +100499,12 @@ var init_terminalApplicationsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsGet.ts
-var args149, tool$terminalApplicationsGet;
+var args153, tool$terminalApplicationsGet;
 var init_terminalApplicationsGet2 = __esm(() => {
   init_terminalApplicationsGet();
   init_operations();
   init_tools();
-  args149 = {
+  args153 = {
     request: GetTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsGet = {
@@ -99742,9 +100513,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: args149,
-    tool: async (client, args150, ctx) => {
-      const [result, apiCall] = await terminalApplicationsGet(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args153,
+    tool: async (client, args154, ctx) => {
+      const [result, apiCall] = await terminalApplicationsGet(client, args154.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99759,9 +100530,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/terminalApplicationsList.ts
 function terminalApplicationsList(client, _request, options) {
-  return new APIPromise($do150(client, _request, options));
+  return new APIPromise($do154(client, _request, options));
 }
-async function $do150(client, _request, options) {
+async function $do154(client, _request, options) {
   const path = pathToFunc("/terminal-applications")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -99825,12 +100596,12 @@ var init_terminalApplicationsList = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsList.ts
-var args150, tool$terminalApplicationsList;
+var args154, tool$terminalApplicationsList;
 var init_terminalApplicationsList2 = __esm(() => {
   init_terminalApplicationsList();
   init_operations();
   init_tools();
-  args150 = {
+  args154 = {
     request: ListTerminalApplicationsRequest$inboundSchema
   };
   tool$terminalApplicationsList = {
@@ -99839,9 +100610,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: args150,
-    tool: async (client, args151, ctx) => {
-      const [result, apiCall] = await terminalApplicationsList(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args154,
+    tool: async (client, args155, ctx) => {
+      const [result, apiCall] = await terminalApplicationsList(client, args155.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99856,9 +100627,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/transfersCreate.ts
 function transfersCreate(client, request, options) {
-  return new APIPromise($do151(client, request, options));
+  return new APIPromise($do155(client, request, options));
 }
-async function $do151(client, request, options) {
+async function $do155(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -99951,12 +100722,12 @@ var init_transfersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreate.ts
-var args151, tool$transfersCreate;
+var args155, tool$transfersCreate;
 var init_transfersCreate2 = __esm(() => {
   init_transfersCreate();
   init_operations();
   init_tools();
-  args151 = {
+  args155 = {
     request: CreateTransferRequest$inboundSchema
   };
   tool$transfersCreate = {
@@ -99967,9 +100738,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: args151,
-    tool: async (client, args152, ctx) => {
-      const [result, apiCall] = await transfersCreate(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args155,
+    tool: async (client, args156, ctx) => {
+      const [result, apiCall] = await transfersCreate(client, args156.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -99984,9 +100755,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersCreateCancellation.ts
 function transfersCreateCancellation(client, request, options) {
-  return new APIPromise($do152(client, request, options));
+  return new APIPromise($do156(client, request, options));
 }
-async function $do152(client, request, options) {
+async function $do156(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -100069,12 +100840,12 @@ var init_transfersCreateCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateCancellation.ts
-var args152, tool$transfersCreateCancellation;
+var args156, tool$transfersCreateCancellation;
 var init_transfersCreateCancellation2 = __esm(() => {
   init_transfersCreateCancellation();
   init_operations();
   init_tools();
-  args152 = {
+  args156 = {
     request: CreateCancellationRequest$inboundSchema
   };
   tool$transfersCreateCancellation = {
@@ -100083,9 +100854,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: args152,
-    tool: async (client, args153, ctx) => {
-      const [result, apiCall] = await transfersCreateCancellation(client, args153.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args156,
+    tool: async (client, args157, ctx) => {
+      const [result, apiCall] = await transfersCreateCancellation(client, args157.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -100100,9 +100871,9 @@ var init_transfersCreateCancellation2 = __esm(() => {
 
 // src/funcs/transfersCreateReversal.ts
 function transfersCreateReversal(client, request, options) {
-  return new APIPromise($do153(client, request, options));
+  return new APIPromise($do157(client, request, options));
 }
-async function $do153(client, request, options) {
+async function $do157(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateReversalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -100201,12 +100972,12 @@ var init_transfersCreateReversal = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateReversal.ts
-var args153, tool$transfersCreateReversal;
+var args157, tool$transfersCreateReversal;
 var init_transfersCreateReversal2 = __esm(() => {
   init_transfersCreateReversal();
   init_operations();
   init_tools();
-  args153 = {
+  args157 = {
     request: CreateReversalRequest$inboundSchema
   };
   tool$transfersCreateReversal = {
@@ -100217,9 +100988,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: args153,
-    tool: async (client, args154, ctx) => {
-      const [result, apiCall] = await transfersCreateReversal(client, args154.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args157,
+    tool: async (client, args158, ctx) => {
+      const [result, apiCall] = await transfersCreateReversal(client, args158.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -100234,9 +101005,9 @@ to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGenerateOptions.ts
 function transfersGenerateOptions(client, request, options) {
-  return new APIPromise($do154(client, request, options));
+  return new APIPromise($do158(client, request, options));
 }
-async function $do154(client, request, options) {
+async function $do158(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateTransferOptionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -100320,12 +101091,12 @@ var init_transfersGenerateOptions = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGenerateOptions.ts
-var args154, tool$transfersGenerateOptions;
+var args158, tool$transfersGenerateOptions;
 var init_transfersGenerateOptions2 = __esm(() => {
   init_transfersGenerateOptions();
   init_operations();
   init_tools();
-  args154 = {
+  args158 = {
     request: CreateTransferOptionsRequest$inboundSchema
   };
   tool$transfersGenerateOptions = {
@@ -100339,9 +101110,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: args154,
-    tool: async (client, args155, ctx) => {
-      const [result, apiCall] = await transfersGenerateOptions(client, args155.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args158,
+    tool: async (client, args159, ctx) => {
+      const [result, apiCall] = await transfersGenerateOptions(client, args159.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -100356,9 +101127,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGet.ts
 function transfersGet(client, request, options) {
-  return new APIPromise($do155(client, request, options));
+  return new APIPromise($do159(client, request, options));
 }
-async function $do155(client, request, options) {
+async function $do159(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -100440,12 +101211,12 @@ var init_transfersGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGet.ts
-var args155, tool$transfersGet;
+var args159, tool$transfersGet;
 var init_transfersGet2 = __esm(() => {
   init_transfersGet();
   init_operations();
   init_tools();
-  args155 = {
+  args159 = {
     request: GetTransferRequest$inboundSchema
   };
   tool$transfersGet = {
@@ -100457,9 +101228,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: args155,
-    tool: async (client, args156, ctx) => {
-      const [result, apiCall] = await transfersGet(client, args156.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args159,
+    tool: async (client, args160, ctx) => {
+      const [result, apiCall] = await transfersGet(client, args160.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -100474,9 +101245,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersGetCancellation.ts
 function transfersGetCancellation(client, request, options) {
-  return new APIPromise($do156(client, request, options));
+  return new APIPromise($do160(client, request, options));
 }
-async function $do156(client, request, options) {
+async function $do160(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -100562,12 +101333,12 @@ var init_transfersGetCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetCancellation.ts
-var args156, tool$transfersGetCancellation;
+var args160, tool$transfersGetCancellation;
 var init_transfersGetCancellation2 = __esm(() => {
   init_transfersGetCancellation();
   init_operations();
   init_tools();
-  args156 = {
+  args160 = {
     request: GetCancellationRequest$inboundSchema
   };
   tool$transfersGetCancellation = {
@@ -100576,9 +101347,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: args156,
-    tool: async (client, args157, ctx) => {
-      const [result, apiCall] = await transfersGetCancellation(client, args157.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args160,
+    tool: async (client, args161, ctx) => {
+      const [result, apiCall] = await transfersGetCancellation(client, args161.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -100593,9 +101364,9 @@ var init_transfersGetCancellation2 = __esm(() => {
 
 // src/funcs/transfersGetRefund.ts
 function transfersGetRefund(client, request, options) {
-  return new APIPromise($do157(client, request, options));
+  return new APIPromise($do161(client, request, options));
 }
-async function $do157(client, request, options) {
+async function $do161(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -100681,12 +101452,12 @@ var init_transfersGetRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetRefund.ts
-var args157, tool$transfersGetRefund;
+var args161, tool$transfersGetRefund;
 var init_transfersGetRefund2 = __esm(() => {
   init_transfersGetRefund();
   init_operations();
   init_tools();
-  args157 = {
+  args161 = {
     request: GetRefundRequest$inboundSchema
   };
   tool$transfersGetRefund = {
@@ -100695,9 +101466,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: args157,
-    tool: async (client, args158, ctx) => {
-      const [result, apiCall] = await transfersGetRefund(client, args158.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args161,
+    tool: async (client, args162, ctx) => {
+      const [result, apiCall] = await transfersGetRefund(client, args162.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -100712,9 +101483,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersInitiateRefund.ts
 function transfersInitiateRefund(client, request, options) {
-  return new APIPromise($do158(client, request, options));
+  return new APIPromise($do162(client, request, options));
 }
-async function $do158(client, request, options) {
+async function $do162(client, request, options) {
   const parsed = safeParse4(request, (value) => InitiateRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -100806,12 +101577,12 @@ var init_transfersInitiateRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersInitiateRefund.ts
-var args158, tool$transfersInitiateRefund;
+var args162, tool$transfersInitiateRefund;
 var init_transfersInitiateRefund2 = __esm(() => {
   init_transfersInitiateRefund();
   init_operations();
   init_tools();
-  args158 = {
+  args162 = {
     request: InitiateRefundRequest$inboundSchema
   };
   tool$transfersInitiateRefund = {
@@ -100823,9 +101594,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: args158,
-    tool: async (client, args159, ctx) => {
-      const [result, apiCall] = await transfersInitiateRefund(client, args159.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args162,
+    tool: async (client, args163, ctx) => {
+      const [result, apiCall] = await transfersInitiateRefund(client, args163.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -100840,9 +101611,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersList.ts
 function transfersList(client, request, options) {
-  return new APIPromise($do159(client, request, options));
+  return new APIPromise($do163(client, request, options));
 }
-async function $do159(client, request, options) {
+async function $do163(client, request, options) {
   const parsed = safeParse4(request, (value) => ListTransfersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -100938,12 +101709,12 @@ var init_transfersList = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersList.ts
-var args159, tool$transfersList;
+var args163, tool$transfersList;
 var init_transfersList2 = __esm(() => {
   init_transfersList();
   init_operations();
   init_tools();
-  args159 = {
+  args163 = {
     request: ListTransfersRequest$inboundSchema
   };
   tool$transfersList = {
@@ -100959,9 +101730,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: args159,
-    tool: async (client, args160, ctx) => {
-      const [result, apiCall] = await transfersList(client, args160.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args163,
+    tool: async (client, args164, ctx) => {
+      const [result, apiCall] = await transfersList(client, args164.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -100976,9 +101747,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersListRefunds.ts
 function transfersListRefunds(client, request, options) {
-  return new APIPromise($do160(client, request, options));
+  return new APIPromise($do164(client, request, options));
 }
-async function $do160(client, request, options) {
+async function $do164(client, request, options) {
   const parsed = safeParse4(request, (value) => ListRefundsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -101060,12 +101831,12 @@ var init_transfersListRefunds = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersListRefunds.ts
-var args160, tool$transfersListRefunds;
+var args164, tool$transfersListRefunds;
 var init_transfersListRefunds2 = __esm(() => {
   init_transfersListRefunds();
   init_operations();
   init_tools();
-  args160 = {
+  args164 = {
     request: ListRefundsRequest$inboundSchema
   };
   tool$transfersListRefunds = {
@@ -101074,9 +101845,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: args160,
-    tool: async (client, args161, ctx) => {
-      const [result, apiCall] = await transfersListRefunds(client, args161.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args164,
+    tool: async (client, args165, ctx) => {
+      const [result, apiCall] = await transfersListRefunds(client, args165.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -101091,9 +101862,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersUpdate.ts
 function transfersUpdate(client, request, options) {
-  return new APIPromise($do161(client, request, options));
+  return new APIPromise($do165(client, request, options));
 }
-async function $do161(client, request, options) {
+async function $do165(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -101179,12 +101950,12 @@ var init_transfersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersUpdate.ts
-var args161, tool$transfersUpdate;
+var args165, tool$transfersUpdate;
 var init_transfersUpdate2 = __esm(() => {
   init_transfersUpdate();
   init_operations();
   init_tools();
-  args161 = {
+  args165 = {
     request: UpdateTransferRequest$inboundSchema
   };
   tool$transfersUpdate = {
@@ -101195,9 +101966,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: args161,
-    tool: async (client, args162, ctx) => {
-      const [result, apiCall] = await transfersUpdate(client, args162.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args165,
+    tool: async (client, args166, ctx) => {
+      const [result, apiCall] = await transfersUpdate(client, args166.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -101212,9 +101983,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/underwritingGet.ts
 function underwritingGet(client, request, options) {
-  return new APIPromise($do162(client, request, options));
+  return new APIPromise($do166(client, request, options));
 }
-async function $do162(client, request, options) {
+async function $do166(client, request, options) {
   const parsed = safeParse4(request, (value) => GetUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -101292,12 +102063,12 @@ var init_underwritingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingGet.ts
-var args162, tool$underwritingGet;
+var args166, tool$underwritingGet;
 var init_underwritingGet2 = __esm(() => {
   init_underwritingGet();
   init_operations();
   init_tools();
-  args162 = {
+  args166 = {
     request: GetUnderwritingRequest$inboundSchema
   };
   tool$underwritingGet = {
@@ -101308,9 +102079,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: args162,
-    tool: async (client, args163, ctx) => {
-      const [result, apiCall] = await underwritingGet(client, args163.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args166,
+    tool: async (client, args167, ctx) => {
+      const [result, apiCall] = await underwritingGet(client, args167.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -101325,9 +102096,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/underwritingSave.ts
 function underwritingSave(client, request, options) {
-  return new APIPromise($do163(client, request, options));
+  return new APIPromise($do167(client, request, options));
 }
-async function $do163(client, request, options) {
+async function $do167(client, request, options) {
   const parsed = safeParse4(request, (value) => SaveUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -101423,12 +102194,12 @@ var init_underwritingSave = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingSave.ts
-var args163, tool$underwritingSave;
+var args167, tool$underwritingSave;
 var init_underwritingSave2 = __esm(() => {
   init_underwritingSave();
   init_operations();
   init_tools();
-  args163 = {
+  args167 = {
     request: SaveUnderwritingRequest$inboundSchema
   };
   tool$underwritingSave = {
@@ -101439,9 +102210,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: args163,
-    tool: async (client, args164, ctx) => {
-      const [result, apiCall] = await underwritingSave(client, args164.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args167,
+    tool: async (client, args168, ctx) => {
+      const [result, apiCall] = await underwritingSave(client, args168.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -101456,9 +102227,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/underwritingUpsert.ts
 function underwritingUpsert(client, request, options) {
-  return new APIPromise($do164(client, request, options));
+  return new APIPromise($do168(client, request, options));
 }
-async function $do164(client, request, options) {
+async function $do168(client, request, options) {
   const parsed = safeParse4(request, (value) => UpsertUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -101554,12 +102325,12 @@ var init_underwritingUpsert = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingUpsert.ts
-var args164, tool$underwritingUpsert;
+var args168, tool$underwritingUpsert;
 var init_underwritingUpsert2 = __esm(() => {
   init_underwritingUpsert();
   init_operations();
   init_tools();
-  args164 = {
+  args168 = {
     request: UpsertUnderwritingRequest$inboundSchema
   };
   tool$underwritingUpsert = {
@@ -101570,9 +102341,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: args164,
-    tool: async (client, args165, ctx) => {
-      const [result, apiCall] = await underwritingUpsert(client, args165.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args168,
+    tool: async (client, args169, ctx) => {
+      const [result, apiCall] = await underwritingUpsert(client, args169.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -101587,9 +102358,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/walletsCreate.ts
 function walletsCreate(client, request, options) {
-  return new APIPromise($do165(client, request, options));
+  return new APIPromise($do169(client, request, options));
 }
-async function $do165(client, request, options) {
+async function $do169(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -101683,12 +102454,12 @@ var init_walletsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsCreate.ts
-var args165, tool$walletsCreate;
+var args169, tool$walletsCreate;
 var init_walletsCreate2 = __esm(() => {
   init_walletsCreate();
   init_operations();
   init_tools();
-  args165 = {
+  args169 = {
     request: CreateWalletRequest$inboundSchema
   };
   tool$walletsCreate = {
@@ -101699,9 +102470,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.write\` scope.`,
-    args: args165,
-    tool: async (client, args166, ctx) => {
-      const [result, apiCall] = await walletsCreate(client, args166.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args169,
+    tool: async (client, args170, ctx) => {
+      const [result, apiCall] = await walletsCreate(client, args170.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -101716,9 +102487,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletsGet.ts
 function walletsGet(client, request, options) {
-  return new APIPromise($do166(client, request, options));
+  return new APIPromise($do170(client, request, options));
 }
-async function $do166(client, request, options) {
+async function $do170(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -101800,12 +102571,12 @@ var init_walletsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsGet.ts
-var args166, tool$walletsGet;
+var args170, tool$walletsGet;
 var init_walletsGet2 = __esm(() => {
   init_walletsGet();
   init_operations();
   init_tools();
-  args166 = {
+  args170 = {
     request: GetWalletRequest$inboundSchema
   };
   tool$walletsGet = {
@@ -101816,9 +102587,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: args166,
-    tool: async (client, args167, ctx) => {
-      const [result, apiCall] = await walletsGet(client, args167.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args170,
+    tool: async (client, args171, ctx) => {
+      const [result, apiCall] = await walletsGet(client, args171.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -101833,9 +102604,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsList.ts
 function walletsList(client, request, options) {
-  return new APIPromise($do167(client, request, options));
+  return new APIPromise($do171(client, request, options));
 }
-async function $do167(client, request, options) {
+async function $do171(client, request, options) {
   const parsed = safeParse4(request, (value) => ListWalletsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -101923,12 +102694,12 @@ var init_walletsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsList.ts
-var args167, tool$walletsList;
+var args171, tool$walletsList;
 var init_walletsList2 = __esm(() => {
   init_walletsList();
   init_operations();
   init_tools();
-  args167 = {
+  args171 = {
     request: ListWalletsRequest$inboundSchema
   };
   tool$walletsList = {
@@ -101939,9 +102710,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: args167,
-    tool: async (client, args168, ctx) => {
-      const [result, apiCall] = await walletsList(client, args168.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args171,
+    tool: async (client, args172, ctx) => {
+      const [result, apiCall] = await walletsList(client, args172.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -101956,9 +102727,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsUpdate.ts
 function walletsUpdate(client, request, options) {
-  return new APIPromise($do168(client, request, options));
+  return new APIPromise($do172(client, request, options));
 }
-async function $do168(client, request, options) {
+async function $do172(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -102056,12 +102827,12 @@ var init_walletsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsUpdate.ts
-var args168, tool$walletsUpdate;
+var args172, tool$walletsUpdate;
 var init_walletsUpdate2 = __esm(() => {
   init_walletsUpdate();
   init_operations();
   init_tools();
-  args168 = {
+  args172 = {
     request: UpdateWalletRequest$inboundSchema
   };
   tool$walletsUpdate = {
@@ -102072,9 +102843,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.write\` scope.`,
-    args: args168,
-    tool: async (client, args169, ctx) => {
-      const [result, apiCall] = await walletsUpdate(client, args169.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args172,
+    tool: async (client, args173, ctx) => {
+      const [result, apiCall] = await walletsUpdate(client, args173.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102089,9 +102860,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletTransactionsGet.ts
 function walletTransactionsGet(client, request, options) {
-  return new APIPromise($do169(client, request, options));
+  return new APIPromise($do173(client, request, options));
 }
-async function $do169(client, request, options) {
+async function $do173(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWalletTransactionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -102177,12 +102948,12 @@ var init_walletTransactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsGet.ts
-var args169, tool$walletTransactionsGet;
+var args173, tool$walletTransactionsGet;
 var init_walletTransactionsGet2 = __esm(() => {
   init_walletTransactionsGet();
   init_operations();
   init_tools();
-  args169 = {
+  args173 = {
     request: GetWalletTransactionRequest$inboundSchema
   };
   tool$walletTransactionsGet = {
@@ -102193,9 +102964,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: args169,
-    tool: async (client, args170, ctx) => {
-      const [result, apiCall] = await walletTransactionsGet(client, args170.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args173,
+    tool: async (client, args174, ctx) => {
+      const [result, apiCall] = await walletTransactionsGet(client, args174.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102210,9 +102981,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletTransactionsList.ts
 function walletTransactionsList(client, request, options) {
-  return new APIPromise($do170(client, request, options));
+  return new APIPromise($do174(client, request, options));
 }
-async function $do170(client, request, options) {
+async function $do174(client, request, options) {
   const parsed = safeParse4(request, (value) => ListWalletTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -102312,12 +103083,12 @@ var init_walletTransactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsList.ts
-var args170, tool$walletTransactionsList;
+var args174, tool$walletTransactionsList;
 var init_walletTransactionsList2 = __esm(() => {
   init_walletTransactionsList();
   init_operations();
   init_tools();
-  args170 = {
+  args174 = {
     request: ListWalletTransactionsRequest$inboundSchema
   };
   tool$walletTransactionsList = {
@@ -102328,9 +103099,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: args170,
-    tool: async (client, args171, ctx) => {
-      const [result, apiCall] = await walletTransactionsList(client, args171.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args174,
+    tool: async (client, args175, ctx) => {
+      const [result, apiCall] = await walletTransactionsList(client, args175.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102345,9 +103116,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/webhooksCreate.ts
 function webhooksCreate(client, request, options) {
-  return new APIPromise($do171(client, request, options));
+  return new APIPromise($do175(client, request, options));
 }
-async function $do171(client, request, options) {
+async function $do175(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateWebhook$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -102436,20 +103207,20 @@ var init_webhooksCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksCreate.ts
-var args171, tool$webhooksCreate;
+var args175, tool$webhooksCreate;
 var init_webhooksCreate2 = __esm(() => {
   init_webhooksCreate();
   init_components();
   init_tools();
-  args171 = {
+  args175 = {
     request: CreateWebhook$inboundSchema
   };
   tool$webhooksCreate = {
     name: "webhooks-create",
     description: `Create a new webhook for the account.`,
-    args: args171,
-    tool: async (client, args172, ctx) => {
-      const [result, apiCall] = await webhooksCreate(client, args172.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args175,
+    tool: async (client, args176, ctx) => {
+      const [result, apiCall] = await webhooksCreate(client, args176.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102464,9 +103235,9 @@ var init_webhooksCreate2 = __esm(() => {
 
 // src/funcs/webhooksDisable.ts
 function webhooksDisable(client, request, options) {
-  return new APIPromise($do172(client, request, options));
+  return new APIPromise($do176(client, request, options));
 }
-async function $do172(client, request, options) {
+async function $do176(client, request, options) {
   const parsed = safeParse4(request, (value) => DisableWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -102555,20 +103326,20 @@ var init_webhooksDisable = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksDisable.ts
-var args172, tool$webhooksDisable;
+var args176, tool$webhooksDisable;
 var init_webhooksDisable2 = __esm(() => {
   init_webhooksDisable();
   init_operations();
   init_tools();
-  args172 = {
+  args176 = {
     request: DisableWebhookRequest$inboundSchema
   };
   tool$webhooksDisable = {
     name: "webhooks-disable",
     description: `Disable a webhook. Disabled webhooks will no longer receive events.`,
-    args: args172,
-    tool: async (client, args173, ctx) => {
-      const [result, apiCall] = await webhooksDisable(client, args173.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args176,
+    tool: async (client, args177, ctx) => {
+      const [result, apiCall] = await webhooksDisable(client, args177.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102582,9 +103353,9 @@ var init_webhooksDisable2 = __esm(() => {
 
 // src/funcs/webhooksGet.ts
 function webhooksGet(client, request, options) {
-  return new APIPromise($do173(client, request, options));
+  return new APIPromise($do177(client, request, options));
 }
-async function $do173(client, request, options) {
+async function $do177(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -102662,20 +103433,20 @@ var init_webhooksGet = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksGet.ts
-var args173, tool$webhooksGet;
+var args177, tool$webhooksGet;
 var init_webhooksGet2 = __esm(() => {
   init_webhooksGet();
   init_operations();
   init_tools();
-  args173 = {
+  args177 = {
     request: GetWebhookRequest$inboundSchema
   };
   tool$webhooksGet = {
     name: "webhooks-get",
     description: `Get details of a specific webhook.`,
-    args: args173,
-    tool: async (client, args174, ctx) => {
-      const [result, apiCall] = await webhooksGet(client, args174.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args177,
+    tool: async (client, args178, ctx) => {
+      const [result, apiCall] = await webhooksGet(client, args178.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102690,9 +103461,9 @@ var init_webhooksGet2 = __esm(() => {
 
 // src/funcs/webhooksGetSecret.ts
 function webhooksGetSecret(client, request, options) {
-  return new APIPromise($do174(client, request, options));
+  return new APIPromise($do178(client, request, options));
 }
-async function $do174(client, request, options) {
+async function $do178(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWebhookSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -102770,20 +103541,20 @@ var init_webhooksGetSecret = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksGetSecret.ts
-var args174, tool$webhooksGetSecret;
+var args178, tool$webhooksGetSecret;
 var init_webhooksGetSecret2 = __esm(() => {
   init_webhooksGetSecret();
   init_operations();
   init_tools();
-  args174 = {
+  args178 = {
     request: GetWebhookSecretRequest$inboundSchema
   };
   tool$webhooksGetSecret = {
     name: "webhooks-get-secret",
     description: `Get the secret key for verifying webhook payloads.`,
-    args: args174,
-    tool: async (client, args175, ctx) => {
-      const [result, apiCall] = await webhooksGetSecret(client, args175.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args178,
+    tool: async (client, args179, ctx) => {
+      const [result, apiCall] = await webhooksGetSecret(client, args179.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102798,9 +103569,9 @@ var init_webhooksGetSecret2 = __esm(() => {
 
 // src/funcs/webhooksList.ts
 function webhooksList(client, _request, options) {
-  return new APIPromise($do175(client, _request, options));
+  return new APIPromise($do179(client, _request, options));
 }
-async function $do175(client, _request, options) {
+async function $do179(client, _request, options) {
   const path = pathToFunc("/webhooks")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -102864,20 +103635,20 @@ var init_webhooksList = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksList.ts
-var args175, tool$webhooksList;
+var args179, tool$webhooksList;
 var init_webhooksList2 = __esm(() => {
   init_webhooksList();
   init_operations();
   init_tools();
-  args175 = {
+  args179 = {
     request: ListWebhooksRequest$inboundSchema
   };
   tool$webhooksList = {
     name: "webhooks-list",
     description: `List all webhooks configured for the account.`,
-    args: args175,
-    tool: async (client, args176, ctx) => {
-      const [result, apiCall] = await webhooksList(client, args176.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args179,
+    tool: async (client, args180, ctx) => {
+      const [result, apiCall] = await webhooksList(client, args180.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102892,9 +103663,9 @@ var init_webhooksList2 = __esm(() => {
 
 // src/funcs/webhooksListEventTypes.ts
 function webhooksListEventTypes(client, _request, options) {
-  return new APIPromise($do176(client, _request, options));
+  return new APIPromise($do180(client, _request, options));
 }
-async function $do176(client, _request, options) {
+async function $do180(client, _request, options) {
   const path = pathToFunc("/event-types")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -102958,20 +103729,20 @@ var init_webhooksListEventTypes = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksListEventTypes.ts
-var args176, tool$webhooksListEventTypes;
+var args180, tool$webhooksListEventTypes;
 var init_webhooksListEventTypes2 = __esm(() => {
   init_webhooksListEventTypes();
   init_operations();
   init_tools();
-  args176 = {
+  args180 = {
     request: ListEventTypesRequest$inboundSchema
   };
   tool$webhooksListEventTypes = {
     name: "webhooks-list-event-types",
     description: `List all available event types that can be subscribed to.`,
-    args: args176,
-    tool: async (client, args177, ctx) => {
-      const [result, apiCall] = await webhooksListEventTypes(client, args177.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args180,
+    tool: async (client, args181, ctx) => {
+      const [result, apiCall] = await webhooksListEventTypes(client, args181.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -102986,9 +103757,9 @@ var init_webhooksListEventTypes2 = __esm(() => {
 
 // src/funcs/webhooksPing.ts
 function webhooksPing(client, request, options) {
-  return new APIPromise($do177(client, request, options));
+  return new APIPromise($do181(client, request, options));
 }
-async function $do177(client, request, options) {
+async function $do181(client, request, options) {
   const parsed = safeParse4(request, (value) => PingWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -103066,20 +103837,20 @@ var init_webhooksPing = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksPing.ts
-var args177, tool$webhooksPing;
+var args181, tool$webhooksPing;
 var init_webhooksPing2 = __esm(() => {
   init_webhooksPing();
   init_operations();
   init_tools();
-  args177 = {
+  args181 = {
     request: PingWebhookRequest$inboundSchema
   };
   tool$webhooksPing = {
     name: "webhooks-ping",
     description: `Send a test ping to a webhook to verify it is configured correctly.`,
-    args: args177,
-    tool: async (client, args178, ctx) => {
-      const [result, apiCall] = await webhooksPing(client, args178.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args181,
+    tool: async (client, args182, ctx) => {
+      const [result, apiCall] = await webhooksPing(client, args182.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -103094,9 +103865,9 @@ var init_webhooksPing2 = __esm(() => {
 
 // src/funcs/webhooksUpdate.ts
 function webhooksUpdate(client, request, options) {
-  return new APIPromise($do178(client, request, options));
+  return new APIPromise($do182(client, request, options));
 }
-async function $do178(client, request, options) {
+async function $do182(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -103190,20 +103961,20 @@ var init_webhooksUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksUpdate.ts
-var args178, tool$webhooksUpdate;
+var args182, tool$webhooksUpdate;
 var init_webhooksUpdate2 = __esm(() => {
   init_webhooksUpdate();
   init_operations();
   init_tools();
-  args178 = {
+  args182 = {
     request: UpdateWebhookRequest$inboundSchema
   };
   tool$webhooksUpdate = {
     name: "webhooks-update",
     description: `Update an existing webhook.`,
-    args: args178,
-    tool: async (client, args179, ctx) => {
-      const [result, apiCall] = await webhooksUpdate(client, args179.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args182,
+    tool: async (client, args183, ctx) => {
+      const [result, apiCall] = await webhooksUpdate(client, args183.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -103220,7 +103991,7 @@ var init_webhooksUpdate2 = __esm(() => {
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Moov",
-    version: "26.4.0-dev.10"
+    version: "26.4.0-dev.11"
   });
   const client = new MoovCore({
     security: deps.security,
@@ -103330,6 +104101,10 @@ function createMCPServer(deps) {
   tool(tool$representativesDelete);
   tool(tool$representativesGet);
   tool(tool$representativesUpdate);
+  tool(tool$resolutionLinksCreate);
+  tool(tool$resolutionLinksList);
+  tool(tool$resolutionLinksGet);
+  tool(tool$resolutionLinksDisable);
   tool(tool$schedulingCreate);
   tool(tool$schedulingList);
   tool(tool$schedulingUpdate);
@@ -103546,6 +104321,10 @@ var init_server2 = __esm(() => {
   init_representativesGet2();
   init_representativesList2();
   init_representativesUpdate2();
+  init_resolutionLinksCreate2();
+  init_resolutionLinksDisable2();
+  init_resolutionLinksGet2();
+  init_resolutionLinksList2();
   init_schedulingCancel2();
   init_schedulingCreate2();
   init_schedulingGet2();
@@ -104800,7 +105579,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "26.4.0-dev.10"
+    currentVersion: "26.4.0-dev.11"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -104808,5 +105587,5 @@ export {
   app
 };
 
-//# debugId=78E5842945605B6764756E2164756E21
+//# debugId=EB0540AC8D69881664756E2164756E21
 //# sourceMappingURL=mcp-server.js.map