@moovio/sdk 0.15.5 → 0.15.7

package/bin/mcp-server.js

@@ -34175,9 +34175,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "latest",
-    sdkVersion: "0.15.5",
-    genVersion: "2.716.16",
-    userAgent: "speakeasy-sdk/typescript 0.15.5 2.716.16 latest @moovio/sdk"
+    sdkVersion: "0.15.7",
+    genVersion: "2.720.1",
+    userAgent: "speakeasy-sdk/typescript 0.15.7 2.720.1 latest @moovio/sdk"
   };
 });
 
@@ -42769,15 +42769,36 @@ var init_moovfeedetails = __esm(() => {
   })(MoovFeeDetails$ ||= {});
 });
 
+// src/models/components/wallettype.ts
+var WalletType, WalletType$inboundSchema, WalletType$outboundSchema, WalletType$;
+var init_wallettype = __esm(() => {
+  init_esm();
+  WalletType = {
+    Default: "default",
+    General: "general"
+  };
+  WalletType$inboundSchema = nativeEnumType(WalletType);
+  WalletType$outboundSchema = WalletType$inboundSchema;
+  ((WalletType$) => {
+    WalletType$.inboundSchema = WalletType$inboundSchema;
+    WalletType$.outboundSchema = WalletType$outboundSchema;
+  })(WalletType$ ||= {});
+});
+
 // src/models/components/paymentmethodswallet.ts
 var PaymentMethodsWallet$inboundSchema, PaymentMethodsWallet$outboundSchema, PaymentMethodsWallet$;
 var init_paymentmethodswallet = __esm(() => {
   init_esm();
+  init_wallettype();
   PaymentMethodsWallet$inboundSchema = objectType({
-    walletID: stringType()
+    walletID: stringType(),
+    partnerAccountID: stringType(),
+    walletType: WalletType$inboundSchema
   });
   PaymentMethodsWallet$outboundSchema = objectType({
-    walletID: stringType()
+    walletID: stringType(),
+    partnerAccountID: stringType(),
+    walletType: WalletType$outboundSchema
   });
   ((PaymentMethodsWallet$) => {
     PaymentMethodsWallet$.inboundSchema = PaymentMethodsWallet$inboundSchema;
@@ -45019,6 +45040,30 @@ var init_governmentiderror = __esm(() => {
   })(GovernmentIDError$ ||= {});
 });
 
+// src/models/components/imagemetadata.ts
+var ImageMetadata$inboundSchema, ImageMetadata$outboundSchema, ImageMetadata$;
+var init_imagemetadata = __esm(() => {
+  init_esm();
+  ImageMetadata$inboundSchema = objectType({
+    imageID: stringType(),
+    altText: stringType().optional(),
+    link: stringType(),
+    createdOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    updatedOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+  });
+  ImageMetadata$outboundSchema = objectType({
+    imageID: stringType(),
+    altText: stringType().optional(),
+    link: stringType(),
+    createdOn: dateType().transform((v2) => v2.toISOString()),
+    updatedOn: dateType().transform((v2) => v2.toISOString())
+  });
+  ((ImageMetadata$) => {
+    ImageMetadata$.inboundSchema = ImageMetadata$inboundSchema;
+    ImageMetadata$.outboundSchema = ImageMetadata$outboundSchema;
+  })(ImageMetadata$ ||= {});
+});
+
 // src/models/components/incurredfee.ts
 var IncurredFee$inboundSchema, IncurredFee$outboundSchema, IncurredFee$;
 var init_incurredfee = __esm(() => {
@@ -47554,12 +47599,12 @@ var Security$inboundSchema, Security$outboundSchema, Security$;
 var init_security2 = __esm(() => {
   init_esm();
   Security$inboundSchema = objectType({
-    username: stringType(),
-    password: stringType()
+    username: stringType().optional(),
+    password: stringType().optional()
   });
   Security$outboundSchema = objectType({
-    username: stringType(),
-    password: stringType()
+    username: stringType().optional(),
+    password: stringType().optional()
   });
   ((Security$) => {
     Security$.inboundSchema = Security$inboundSchema;
@@ -48908,22 +48953,6 @@ var init_walletavailablebalance = __esm(() => {
   })(WalletAvailableBalance$ ||= {});
 });
 
-// src/models/components/wallettype.ts
-var WalletType, WalletType$inboundSchema, WalletType$outboundSchema, WalletType$;
-var init_wallettype = __esm(() => {
-  init_esm();
-  WalletType = {
-    Default: "default",
-    General: "general"
-  };
-  WalletType$inboundSchema = nativeEnumType(WalletType);
-  WalletType$outboundSchema = WalletType$inboundSchema;
-  ((WalletType$) => {
-    WalletType$.inboundSchema = WalletType$inboundSchema;
-    WalletType$.outboundSchema = WalletType$outboundSchema;
-  })(WalletType$ ||= {});
-});
-
 // src/models/components/wallet.ts
 var Wallet$inboundSchema, Wallet$outboundSchema, Wallet$;
 var init_wallet = __esm(() => {
@@ -50261,6 +50290,7 @@ var init_components = __esm(() => {
   init_governmentiderror();
   init_granttype();
   init_guestprofile();
+  init_imagemetadata();
   init_incurredfee();
   init_individualname();
   init_individualnameerror();
@@ -54553,6 +54583,61 @@ var init_deletedisputeevidencefile = __esm(() => {
   })(DeleteDisputeEvidenceFileResponse$ ||= {});
 });
 
+// src/models/operations/deleteimage.ts
+var DeleteImageGlobals$inboundSchema, DeleteImageGlobals$outboundSchema, DeleteImageGlobals$, DeleteImageRequest$inboundSchema, DeleteImageRequest$outboundSchema, DeleteImageRequest$, DeleteImageResponse$inboundSchema, DeleteImageResponse$outboundSchema, DeleteImageResponse$;
+var init_deleteimage = __esm(() => {
+  init_esm();
+  init_primitives();
+  DeleteImageGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  DeleteImageGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((DeleteImageGlobals$) => {
+    DeleteImageGlobals$.inboundSchema = DeleteImageGlobals$inboundSchema;
+    DeleteImageGlobals$.outboundSchema = DeleteImageGlobals$outboundSchema;
+  })(DeleteImageGlobals$ ||= {});
+  DeleteImageRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    imageID: stringType()
+  });
+  DeleteImageRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    imageID: stringType()
+  });
+  ((DeleteImageRequest$) => {
+    DeleteImageRequest$.inboundSchema = DeleteImageRequest$inboundSchema;
+    DeleteImageRequest$.outboundSchema = DeleteImageRequest$outboundSchema;
+  })(DeleteImageRequest$ ||= {});
+  DeleteImageResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType()))
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers"
+    });
+  });
+  DeleteImageResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType()))
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers"
+    });
+  });
+  ((DeleteImageResponse$) => {
+    DeleteImageResponse$.inboundSchema = DeleteImageResponse$inboundSchema;
+    DeleteImageResponse$.outboundSchema = DeleteImageResponse$outboundSchema;
+  })(DeleteImageResponse$ ||= {});
+});
+
 // src/models/operations/deleterepresentative.ts
 var DeleteRepresentativeGlobals$inboundSchema, DeleteRepresentativeGlobals$outboundSchema, DeleteRepresentativeGlobals$, DeleteRepresentativeRequest$inboundSchema, DeleteRepresentativeRequest$outboundSchema, DeleteRepresentativeRequest$, DeleteRepresentativeResponse$inboundSchema, DeleteRepresentativeResponse$outboundSchema, DeleteRepresentativeResponse$;
 var init_deleterepresentative = __esm(() => {
@@ -56165,6 +56250,66 @@ var init_getfullissuedcard = __esm(() => {
   })(GetFullIssuedCardResponse$ ||= {});
 });
 
+// src/models/operations/getimagemetadata.ts
+var GetImageMetadataGlobals$inboundSchema, GetImageMetadataGlobals$outboundSchema, GetImageMetadataGlobals$, GetImageMetadataRequest$inboundSchema, GetImageMetadataRequest$outboundSchema, GetImageMetadataRequest$, GetImageMetadataResponse$inboundSchema, GetImageMetadataResponse$outboundSchema, GetImageMetadataResponse$;
+var init_getimagemetadata = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  GetImageMetadataGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  GetImageMetadataGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((GetImageMetadataGlobals$) => {
+    GetImageMetadataGlobals$.inboundSchema = GetImageMetadataGlobals$inboundSchema;
+    GetImageMetadataGlobals$.outboundSchema = GetImageMetadataGlobals$outboundSchema;
+  })(GetImageMetadataGlobals$ ||= {});
+  GetImageMetadataRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    imageID: stringType()
+  });
+  GetImageMetadataRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    imageID: stringType()
+  });
+  ((GetImageMetadataRequest$) => {
+    GetImageMetadataRequest$.inboundSchema = GetImageMetadataRequest$inboundSchema;
+    GetImageMetadataRequest$.outboundSchema = GetImageMetadataRequest$outboundSchema;
+  })(GetImageMetadataRequest$ ||= {});
+  GetImageMetadataResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: ImageMetadata$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  GetImageMetadataResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: ImageMetadata$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((GetImageMetadataResponse$) => {
+    GetImageMetadataResponse$.inboundSchema = GetImageMetadataResponse$inboundSchema;
+    GetImageMetadataResponse$.outboundSchema = GetImageMetadataResponse$outboundSchema;
+  })(GetImageMetadataResponse$ ||= {});
+});
+
 // src/models/operations/getissuedcard.ts
 var GetIssuedCardGlobals$inboundSchema, GetIssuedCardGlobals$outboundSchema, GetIssuedCardGlobals$, GetIssuedCardRequest$inboundSchema, GetIssuedCardRequest$outboundSchema, GetIssuedCardRequest$, GetIssuedCardResponse$inboundSchema, GetIssuedCardResponse$outboundSchema, GetIssuedCardResponse$;
 var init_getissuedcard = __esm(() => {
@@ -56658,6 +56803,79 @@ var init_getpaymentmethod = __esm(() => {
   })(GetPaymentMethodResponse$ ||= {});
 });
 
+// src/models/operations/getpublicimage.ts
+var GetPublicImageRequest$inboundSchema, GetPublicImageRequest$outboundSchema, GetPublicImageRequest$, GetPublicImageResponseResult$inboundSchema, GetPublicImageResponseResult$outboundSchema, GetPublicImageResponseResult$, GetPublicImageResponse$inboundSchema, GetPublicImageResponse$outboundSchema, GetPublicImageResponse$;
+var init_getpublicimage = __esm(() => {
+  init_esm();
+  init_primitives();
+  GetPublicImageRequest$inboundSchema = objectType({
+    "if-none-match": stringType().optional(),
+    publicID: stringType(),
+    size: stringType().default("400x400")
+  }).transform((v2) => {
+    return remap(v2, {
+      "if-none-match": "ifNoneMatch"
+    });
+  });
+  GetPublicImageRequest$outboundSchema = objectType({
+    ifNoneMatch: stringType().optional(),
+    publicID: stringType(),
+    size: stringType().default("400x400")
+  }).transform((v2) => {
+    return remap(v2, {
+      ifNoneMatch: "if-none-match"
+    });
+  });
+  ((GetPublicImageRequest$) => {
+    GetPublicImageRequest$.inboundSchema = GetPublicImageRequest$inboundSchema;
+    GetPublicImageRequest$.outboundSchema = GetPublicImageRequest$outboundSchema;
+  })(GetPublicImageRequest$ ||= {});
+  GetPublicImageResponseResult$inboundSchema = unionType([
+    instanceOfType(ReadableStream),
+    instanceOfType(ReadableStream),
+    instanceOfType(ReadableStream)
+  ]);
+  GetPublicImageResponseResult$outboundSchema = unionType([
+    instanceOfType(ReadableStream),
+    instanceOfType(ReadableStream),
+    instanceOfType(ReadableStream)
+  ]);
+  ((GetPublicImageResponseResult$) => {
+    GetPublicImageResponseResult$.inboundSchema = GetPublicImageResponseResult$inboundSchema;
+    GetPublicImageResponseResult$.outboundSchema = GetPublicImageResponseResult$outboundSchema;
+  })(GetPublicImageResponseResult$ ||= {});
+  GetPublicImageResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: unionType([
+      instanceOfType(ReadableStream),
+      instanceOfType(ReadableStream),
+      instanceOfType(ReadableStream)
+    ])
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  GetPublicImageResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: unionType([
+      instanceOfType(ReadableStream),
+      instanceOfType(ReadableStream),
+      instanceOfType(ReadableStream)
+    ])
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((GetPublicImageResponse$) => {
+    GetPublicImageResponse$.inboundSchema = GetPublicImageResponse$inboundSchema;
+    GetPublicImageResponse$.outboundSchema = GetPublicImageResponse$outboundSchema;
+  })(GetPublicImageResponse$ ||= {});
+});
+
 // src/models/operations/getrefund.ts
 var GetRefundGlobals$inboundSchema, GetRefundGlobals$outboundSchema, GetRefundGlobals$, GetRefundRequest$inboundSchema, GetRefundRequest$outboundSchema, GetRefundRequest$, GetRefundResponse$inboundSchema, GetRefundResponse$outboundSchema, GetRefundResponse$;
 var init_getrefund = __esm(() => {
@@ -58841,6 +59059,64 @@ var init_listfiles = __esm(() => {
   })(ListFilesResponse$ ||= {});
 });
 
+// src/models/operations/listimagemetadata.ts
+var ListImageMetadataGlobals$inboundSchema, ListImageMetadataGlobals$outboundSchema, ListImageMetadataGlobals$, ListImageMetadataRequest$inboundSchema, ListImageMetadataRequest$outboundSchema, ListImageMetadataRequest$, ListImageMetadataResponse$inboundSchema, ListImageMetadataResponse$outboundSchema, ListImageMetadataResponse$;
+var init_listimagemetadata = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ListImageMetadataGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  ListImageMetadataGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((ListImageMetadataGlobals$) => {
+    ListImageMetadataGlobals$.inboundSchema = ListImageMetadataGlobals$inboundSchema;
+    ListImageMetadataGlobals$.outboundSchema = ListImageMetadataGlobals$outboundSchema;
+  })(ListImageMetadataGlobals$ ||= {});
+  ListImageMetadataRequest$inboundSchema = objectType({
+    accountID: stringType()
+  });
+  ListImageMetadataRequest$outboundSchema = objectType({
+    accountID: stringType()
+  });
+  ((ListImageMetadataRequest$) => {
+    ListImageMetadataRequest$.inboundSchema = ListImageMetadataRequest$inboundSchema;
+    ListImageMetadataRequest$.outboundSchema = ListImageMetadataRequest$outboundSchema;
+  })(ListImageMetadataRequest$ ||= {});
+  ListImageMetadataResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: arrayType(ImageMetadata$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ListImageMetadataResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: arrayType(ImageMetadata$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((ListImageMetadataResponse$) => {
+    ListImageMetadataResponse$.inboundSchema = ListImageMetadataResponse$inboundSchema;
+    ListImageMetadataResponse$.outboundSchema = ListImageMetadataResponse$outboundSchema;
+  })(ListImageMetadataResponse$ ||= {});
+});
+
 // src/models/operations/listindustries.ts
 var ListIndustriesGlobals$inboundSchema, ListIndustriesGlobals$outboundSchema, ListIndustriesGlobals$, ListIndustriesRequest$inboundSchema, ListIndustriesRequest$outboundSchema, ListIndustriesRequest$, ListIndustriesResponse$inboundSchema, ListIndustriesResponse$outboundSchema, ListIndustriesResponse$;
 var init_listindustries = __esm(() => {
@@ -62311,6 +62587,7 @@ var init_operations = __esm(() => {
   init_createtransferoptions2();
   init_createwallet2();
   init_deletedisputeevidencefile();
+  init_deleteimage();
   init_deleterepresentative();
   init_deleteterminalapplication();
   init_disablebankaccount();
@@ -62338,6 +62615,7 @@ var init_operations = __esm(() => {
   init_getenrichmentprofile();
   init_getfiledetails();
   init_getfullissuedcard();
+  init_getimagemetadata();
   init_getissuedcard();
   init_getissuedcardauthorization();
   init_getissuedcardtransaction();
@@ -62346,6 +62624,7 @@ var init_operations = __esm(() => {
   init_getpaymentlink();
   init_getpaymentlinkqrcode();
   init_getpaymentmethod();
+  init_getpublicimage();
   init_getrefund();
   init_getrepresentative();
   init_getscheduledoccurrence();
@@ -62380,6 +62659,7 @@ var init_operations = __esm(() => {
   init_listfeeplans();
   init_listfeesfetch();
   init_listfiles();
+  init_listimagemetadata();
   init_listindustries();
   init_listinstitutions();
   init_listissuedcardauthorizationevents();
@@ -71323,7 +71603,500 @@ async function $do73(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, GetFileDetailsResponse$inboundSchema, {
+  const [result] = await match(json(200, GetFileDetailsResponse$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_filesGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/filesGet.ts
+var args73, tool$filesGet;
+var init_filesGet2 = __esm(() => {
+  init_filesGet();
+  init_operations();
+  init_tools();
+  args73 = {
+    request: GetFileDetailsRequest$inboundSchema
+  };
+  tool$filesGet = {
+    name: "files-get",
+    description: `Retrieve file details associated with a specific Moov account.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/files.read\` scope.`,
+    args: args73,
+    tool: async (client, args74, ctx) => {
+      const [result, apiCall] = await filesGet(client, args74.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/filesList.ts
+function filesList(client, request, options) {
+  return new APIPromise($do74(client, request, options));
+}
+async function $do74(client, request, options) {
+  const parsed = safeParse(request, (value) => ListFilesRequest$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}/files")(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: "listFiles",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "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, ListFilesResponse$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_filesList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/filesList.ts
+var args74, tool$filesList;
+var init_filesList2 = __esm(() => {
+  init_filesList();
+  init_operations();
+  init_tools();
+  args74 = {
+    request: ListFilesRequest$inboundSchema
+  };
+  tool$filesList = {
+    name: "files-list",
+    description: `List all the files associated with a particular Moov account.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/files.read\` scope.`,
+    args: args74,
+    tool: async (client, args75, ctx) => {
+      const [result, apiCall] = await filesList(client, args75.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/filesUpload.ts
+function filesUpload(client, request, options) {
+  return new APIPromise($do75(client, request, options));
+}
+async function $do75(client, request, options) {
+  const parsed = safeParse(request, (value) => UploadFileRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = new FormData;
+  if (isBlobLike(payload.FileUploadRequestMultiPart.file)) {
+    appendForm(body, "file", payload.FileUploadRequestMultiPart.file);
+  } else if (isReadableStream(payload.FileUploadRequestMultiPart.file.content)) {
+    const buffer = await readableStreamToArrayBuffer(payload.FileUploadRequestMultiPart.file.content);
+    const contentType2 = getContentTypeFromFileName(payload.FileUploadRequestMultiPart.file.fileName) || "application/octet-stream";
+    const blob = new Blob([buffer], { type: contentType2 });
+    appendForm(body, "file", blob, payload.FileUploadRequestMultiPart.file.fileName);
+  } else {
+    const contentType2 = getContentTypeFromFileName(payload.FileUploadRequestMultiPart.file.fileName) || "application/octet-stream";
+    appendForm(body, "file", new Blob([payload.FileUploadRequestMultiPart.file.content], {
+      type: contentType2
+    }), payload.FileUploadRequestMultiPart.file.fileName);
+  }
+  appendForm(body, "filePurpose", payload.FileUploadRequestMultiPart.filePurpose);
+  if (payload.FileUploadRequestMultiPart.metadata !== undefined) {
+    appendForm(body, "metadata", payload.FileUploadRequestMultiPart.metadata);
+  }
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/files")(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: "uploadFile",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, UploadFileResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, FileValidationError$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_filesUpload = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+  init_blobs();
+});
+
+// src/mcp-server/tools/filesUpload.ts
+var args75, tool$filesUpload;
+var init_filesUpload2 = __esm(() => {
+  init_filesUpload();
+  init_operations();
+  init_tools();
+  args75 = {
+    request: UploadFileRequest$inboundSchema
+  };
+  tool$filesUpload = {
+    name: "files-upload",
+    description: `Upload a file and link it to the specified Moov account. 
+
+The maximum file size is 20MB. Each account is allowed a maximum of 50 files. Acceptable file types include csv, jpg, pdf, 
+and png. 
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/files.write\` scope.`,
+    args: args75,
+    tool: async (client, args76, ctx) => {
+      const [result, apiCall] = await filesUpload(client, args76.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/imagesDelete.ts
+function imagesDelete(client, request, options) {
+  return new APIPromise($do76(client, request, options));
+}
+async function $do76(client, request, options) {
+  const parsed = safeParse(request, (value) => DeleteImageRequest$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"
+    }),
+    imageID: encodeSimple("imageID", payload.imageID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/images/{imageID}")(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: "deleteImage",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "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, DeleteImageResponse$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_imagesDelete = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/imagesDelete.ts
+var args76, tool$imagesDelete;
+var init_imagesDelete2 = __esm(() => {
+  init_imagesDelete();
+  init_operations();
+  init_tools();
+  args76 = {
+    request: DeleteImageRequest$inboundSchema
+  };
+  tool$imagesDelete = {
+    name: "images-delete",
+    description: `Permanently delete an image by its ID.`,
+    args: args76,
+    tool: async (client, args77, ctx) => {
+      const [result, apiCall] = await imagesDelete(client, args77.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/imagesGetMetadata.ts
+function imagesGetMetadata(client, request, options) {
+  return new APIPromise($do77(client, request, options));
+}
+async function $do77(client, request, options) {
+  const parsed = safeParse(request, (value) => GetImageMetadataRequest$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"
+    }),
+    imageID: encodeSimple("imageID", payload.imageID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/images/{imageID}")(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: "getImageMetadata",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "404", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, GetImageMetadataResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
   }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
@@ -71332,7 +72105,7 @@ async function $do73(client, request, options) {
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_filesGet = __esm(() => {
+var init_imagesGetMetadata = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -71343,24 +72116,21 @@ var init_filesGet = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/filesGet.ts
-var args73, tool$filesGet;
-var init_filesGet2 = __esm(() => {
-  init_filesGet();
+// src/mcp-server/tools/imagesGetMetadata.ts
+var args77, tool$imagesGetMetadata;
+var init_imagesGetMetadata2 = __esm(() => {
+  init_imagesGetMetadata();
   init_operations();
   init_tools();
-  args73 = {
-    request: GetFileDetailsRequest$inboundSchema
+  args77 = {
+    request: GetImageMetadataRequest$inboundSchema
   };
-  tool$filesGet = {
-    name: "files-get",
-    description: `Retrieve file details associated with a specific Moov account.
-
-To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/files.read\` scope.`,
-    args: args73,
-    tool: async (client, args74, ctx) => {
-      const [result, apiCall] = await filesGet(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$imagesGetMetadata = {
+    name: "images-get-metadata",
+    description: `Retrieve metadata for a specific image by its ID.`,
+    args: args77,
+    tool: async (client, args78, ctx) => {
+      const [result, apiCall] = await imagesGetMetadata(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71373,46 +72143,50 @@ you'll need to specify the \`/accounts/{accountID}/files.read\` scope.`,
   };
 });
 
-// src/funcs/filesList.ts
-function filesList(client, request, options) {
-  return new APIPromise($do74(client, request, options));
+// src/funcs/imagesGetPublic.ts
+function imagesGetPublic(client, request, options) {
+  return new APIPromise($do78(client, request, options));
 }
-async function $do74(client, request, options) {
-  const parsed = safeParse(request, (value) => ListFilesRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do78(client, request, options) {
+  const parsed = safeParse(request, (value) => GetPublicImageRequest$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, {
+    publicID: encodeSimple("publicID", payload.publicID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/files")(pathParams);
+  const path = pathToFunc("/images/{publicID}")(pathParams);
+  const query = encodeFormQuery({
+    size: payload.size
+  }, { explode: false });
   const headers = new Headers(compactMap({
-    Accept: "application/json",
-    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+    Accept: options?.acceptHeaderOverride || "image/jpeg;q=1, image/png;q=0.7, image/webp;q=0",
+    "if-none-match": encodeSimple("if-none-match", payload["if-none-match"], {
+      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: "listFiles",
+    operationID: "getPublicImage",
     oAuth2Scopes: [],
-    resolvedSecurity: requestSecurity,
-    securitySource: client._options.security,
+    resolvedSecurity: null,
+    securitySource: null,
     retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
     retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
   };
   const requestRes = client._createRequest(context, {
-    security: requestSecurity,
     method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -71423,7 +72197,7 @@ async function $do74(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
+    errorCodes: ["404", "429", "4XX", "500", "502", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -71434,91 +72208,81 @@ async function $do74(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, ListFilesResponse$inboundSchema, {
+  const [result] = await match(stream(200, GetPublicImageResponse$inboundSchema.optional(), {
+    ctype: "image/webp",
     hdrs: true,
     key: "Result"
-  }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  }), stream(200, GetPublicImageResponse$inboundSchema.optional(), {
+    ctype: "image/png",
+    hdrs: true,
+    key: "Result"
+  }), stream(200, GetPublicImageResponse$inboundSchema.optional(), {
+    ctype: "image/jpeg",
+    hdrs: true,
+    key: "Result"
+  }), nil(304, GetPublicImageResponse$inboundSchema.optional(), {
+    hdrs: true
+  }), fail([404, 429]), fail([500, 502, 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_filesList = __esm(() => {
+var init_imagesGetPublic = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
-  init_security();
   init_url();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/filesList.ts
-var args74, tool$filesList;
-var init_filesList2 = __esm(() => {
-  init_filesList();
+// src/mcp-server/tools/imagesGetPublic.ts
+var args78, tool$imagesGetPublic;
+var init_imagesGetPublic2 = __esm(() => {
+  init_imagesGetPublic();
   init_operations();
   init_tools();
-  args74 = {
-    request: ListFilesRequest$inboundSchema
+  args78 = {
+    request: GetPublicImageRequest$inboundSchema
   };
-  tool$filesList = {
-    name: "files-list",
-    description: `List all the files associated with a particular Moov account.
-
-To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/files.read\` scope.`,
-    args: args74,
-    tool: async (client, args75, ctx) => {
-      const [result, apiCall] = await filesList(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$imagesGetPublic = {
+    name: "images-get-public",
+    description: `Get an image by its public ID.`,
+    args: args78,
+    tool: async (client, args79, ctx) => {
+      const [result, apiCall] = await imagesGetPublic(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      const value = result.value.result;
+      const value = result.value?.result;
       return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/filesUpload.ts
-function filesUpload(client, request, options) {
-  return new APIPromise($do75(client, request, options));
+// src/funcs/imagesList.ts
+function imagesList(client, request, options) {
+  return new APIPromise($do79(client, request, options));
 }
-async function $do75(client, request, options) {
-  const parsed = safeParse(request, (value) => UploadFileRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do79(client, request, options) {
+  const parsed = safeParse(request, (value) => ListImageMetadataRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = new FormData;
-  if (isBlobLike(payload.FileUploadRequestMultiPart.file)) {
-    appendForm(body, "file", payload.FileUploadRequestMultiPart.file);
-  } else if (isReadableStream(payload.FileUploadRequestMultiPart.file.content)) {
-    const buffer = await readableStreamToArrayBuffer(payload.FileUploadRequestMultiPart.file.content);
-    const contentType2 = getContentTypeFromFileName(payload.FileUploadRequestMultiPart.file.fileName) || "application/octet-stream";
-    const blob = new Blob([buffer], { type: contentType2 });
-    appendForm(body, "file", blob, payload.FileUploadRequestMultiPart.file.fileName);
-  } else {
-    const contentType2 = getContentTypeFromFileName(payload.FileUploadRequestMultiPart.file.fileName) || "application/octet-stream";
-    appendForm(body, "file", new Blob([payload.FileUploadRequestMultiPart.file.content], {
-      type: contentType2
-    }), payload.FileUploadRequestMultiPart.file.fileName);
-  }
-  appendForm(body, "filePurpose", payload.FileUploadRequestMultiPart.filePurpose);
-  if (payload.FileUploadRequestMultiPart.metadata !== undefined) {
-    appendForm(body, "metadata", payload.FileUploadRequestMultiPart.metadata);
-  }
+  const body = null;
   const pathParams = {
     accountID: encodeSimple("accountID", payload.accountID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/files")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/images")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
@@ -71528,7 +72292,7 @@ async function $do75(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "uploadFile",
+    operationID: "listImageMetadata",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -71537,7 +72301,7 @@ async function $do75(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -71551,19 +72315,7 @@ async function $do75(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: [
-      "400",
-      "401",
-      "403",
-      "404",
-      "409",
-      "422",
-      "429",
-      "4XX",
-      "500",
-      "504",
-      "5XX"
-    ],
+    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -71574,49 +72326,41 @@ async function $do75(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, UploadFileResponse$inboundSchema, {
+  const [result] = await match(json(200, ListImageMetadataResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
-  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, FileValidationError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_filesUpload = __esm(() => {
+var init_imagesList = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
-  init_errors2();
   init_operations();
   init_async();
-  init_blobs();
 });
 
-// src/mcp-server/tools/filesUpload.ts
-var args75, tool$filesUpload;
-var init_filesUpload2 = __esm(() => {
-  init_filesUpload();
+// src/mcp-server/tools/imagesList.ts
+var args79, tool$imagesList;
+var init_imagesList2 = __esm(() => {
+  init_imagesList();
   init_operations();
   init_tools();
-  args75 = {
-    request: UploadFileRequest$inboundSchema
+  args79 = {
+    request: ListImageMetadataRequest$inboundSchema
   };
-  tool$filesUpload = {
-    name: "files-upload",
-    description: `Upload a file and link it to the specified Moov account. 
-
-The maximum file size is 20MB. Each account is allowed a maximum of 50 files. Acceptable file types include csv, jpg, pdf, 
-and png. 
-
-To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/files.write\` scope.`,
-    args: args75,
-    tool: async (client, args76, ctx) => {
-      const [result, apiCall] = await filesUpload(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+  tool$imagesList = {
+    name: "images-list",
+    description: `List metadata for all images in the specified account.`,
+    args: args79,
+    tool: async (client, args80, ctx) => {
+      const [result, apiCall] = await imagesList(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71631,9 +72375,9 @@ you'll need to specify the \`/accounts/{accountID}/files.write\` scope.`,
 
 // src/funcs/industriesList.ts
 function industriesList(client, _request, options) {
-  return new APIPromise($do76(client, _request, options));
+  return new APIPromise($do80(client, _request, options));
 }
-async function $do76(client, _request, options) {
+async function $do80(client, _request, options) {
   const path = pathToFunc("/industries")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -71697,12 +72441,12 @@ var init_industriesList = __esm(() => {
 });
 
 // src/mcp-server/tools/industriesList.ts
-var args76, tool$industriesList;
+var args80, tool$industriesList;
 var init_industriesList2 = __esm(() => {
   init_industriesList();
   init_operations();
   init_tools();
-  args76 = {
+  args80 = {
     request: ListIndustriesRequest$inboundSchema
   };
   tool$industriesList = {
@@ -71711,9 +72455,9 @@ var init_industriesList2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/),
 you'll need to specify the \`/profile-enrichment.read\` scope.`,
-    args: args76,
-    tool: async (client, args77, ctx) => {
-      const [result, apiCall] = await industriesList(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args80,
+    tool: async (client, args81, ctx) => {
+      const [result, apiCall] = await industriesList(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71728,9 +72472,9 @@ you'll need to specify the \`/profile-enrichment.read\` scope.`,
 
 // src/funcs/institutionsSearch.ts
 function institutionsSearch(client, request, options) {
-  return new APIPromise($do77(client, request, options));
+  return new APIPromise($do81(client, request, options));
 }
-async function $do77(client, request, options) {
+async function $do81(client, request, options) {
   const parsed = safeParse(request, (value) => ListInstitutionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71810,12 +72554,12 @@ var init_institutionsSearch = __esm(() => {
 });
 
 // src/mcp-server/tools/institutionsSearch.ts
-var args77, tool$institutionsSearch;
+var args81, tool$institutionsSearch;
 var init_institutionsSearch2 = __esm(() => {
   init_institutionsSearch();
   init_operations();
   init_tools();
-  args77 = {
+  args81 = {
     request: ListInstitutionsRequest$inboundSchema
   };
   tool$institutionsSearch = {
@@ -71824,9 +72568,9 @@ var init_institutionsSearch2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/fed.read\` scope.`,
-    args: args77,
-    tool: async (client, args78, ctx) => {
-      const [result, apiCall] = await institutionsSearch(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args81,
+    tool: async (client, args82, ctx) => {
+      const [result, apiCall] = await institutionsSearch(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71841,9 +72585,9 @@ you'll need to specify the \`/fed.read\` scope.`,
 
 // src/funcs/institutionsSearchInstitutions.ts
 function institutionsSearchInstitutions(client, request, options) {
-  return new APIPromise($do78(client, request, options));
+  return new APIPromise($do82(client, request, options));
 }
-async function $do78(client, request, options) {
+async function $do82(client, request, options) {
   const parsed = safeParse(request, (value) => SearchInstitutionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71921,12 +72665,12 @@ var init_institutionsSearchInstitutions = __esm(() => {
 });
 
 // src/mcp-server/tools/institutionsSearchInstitutions.ts
-var args78, tool$institutionsSearchInstitutions;
+var args82, tool$institutionsSearchInstitutions;
 var init_institutionsSearchInstitutions2 = __esm(() => {
   init_institutionsSearchInstitutions();
   init_operations();
   init_tools();
-  args78 = {
+  args82 = {
     request: SearchInstitutionsRequest$inboundSchema
   };
   tool$institutionsSearchInstitutions = {
@@ -71939,9 +72683,9 @@ This can be used to validate a financial institution before initiating payment a
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/)
 you'll need to specify the \`/institutions.read\` scope.`,
-    args: args78,
-    tool: async (client, args79, ctx) => {
-      const [result, apiCall] = await institutionsSearchInstitutions(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args82,
+    tool: async (client, args83, ctx) => {
+      const [result, apiCall] = await institutionsSearchInstitutions(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71956,9 +72700,9 @@ you'll need to specify the \`/institutions.read\` scope.`,
 
 // src/funcs/issuingTransactionsGet.ts
 function issuingTransactionsGet(client, request, options) {
-  return new APIPromise($do79(client, request, options));
+  return new APIPromise($do83(client, request, options));
 }
-async function $do79(client, request, options) {
+async function $do83(client, request, options) {
   const parsed = safeParse(request, (value) => GetIssuedCardTransactionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72037,12 +72781,12 @@ var init_issuingTransactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsGet.ts
-var args79, tool$issuingTransactionsGet;
+var args83, tool$issuingTransactionsGet;
 var init_issuingTransactionsGet2 = __esm(() => {
   init_issuingTransactionsGet();
   init_operations();
   init_tools();
-  args79 = {
+  args83 = {
     request: GetIssuedCardTransactionRequest$inboundSchema
   };
   tool$issuingTransactionsGet = {
@@ -72051,9 +72795,9 @@ var init_issuingTransactionsGet2 = __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}/issued-cards.read\` scope.`,
-    args: args79,
-    tool: async (client, args80, ctx) => {
-      const [result, apiCall] = await issuingTransactionsGet(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args83,
+    tool: async (client, args84, ctx) => {
+      const [result, apiCall] = await issuingTransactionsGet(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72068,9 +72812,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/issuingTransactionsGetAuthorization.ts
 function issuingTransactionsGetAuthorization(client, request, options) {
-  return new APIPromise($do80(client, request, options));
+  return new APIPromise($do84(client, request, options));
 }
-async function $do80(client, request, options) {
+async function $do84(client, request, options) {
   const parsed = safeParse(request, (value) => GetIssuedCardAuthorizationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72152,12 +72896,12 @@ var init_issuingTransactionsGetAuthorization = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsGetAuthorization.ts
-var args80, tool$issuingTransactionsGetAuthorization;
+var args84, tool$issuingTransactionsGetAuthorization;
 var init_issuingTransactionsGetAuthorization2 = __esm(() => {
   init_issuingTransactionsGetAuthorization();
   init_operations();
   init_tools();
-  args80 = {
+  args84 = {
     request: GetIssuedCardAuthorizationRequest$inboundSchema
   };
   tool$issuingTransactionsGetAuthorization = {
@@ -72166,9 +72910,9 @@ var init_issuingTransactionsGetAuthorization2 = __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}/issued-cards.read\` scope.`,
-    args: args80,
-    tool: async (client, args81, ctx) => {
-      const [result, apiCall] = await issuingTransactionsGetAuthorization(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args84,
+    tool: async (client, args85, ctx) => {
+      const [result, apiCall] = await issuingTransactionsGetAuthorization(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72183,9 +72927,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/issuingTransactionsList.ts
 function issuingTransactionsList(client, request, options) {
-  return new APIPromise($do81(client, request, options));
+  return new APIPromise($do85(client, request, options));
 }
-async function $do81(client, request, options) {
+async function $do85(client, request, options) {
   const parsed = safeParse(request, (value) => ListIssuedCardTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72271,12 +73015,12 @@ var init_issuingTransactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsList.ts
-var args81, tool$issuingTransactionsList;
+var args85, tool$issuingTransactionsList;
 var init_issuingTransactionsList2 = __esm(() => {
   init_issuingTransactionsList();
   init_operations();
   init_tools();
-  args81 = {
+  args85 = {
     request: ListIssuedCardTransactionsRequest$inboundSchema
   };
   tool$issuingTransactionsList = {
@@ -72285,9 +73029,9 @@ var init_issuingTransactionsList2 = __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}/issued-cards.read\` scope.`,
-    args: args81,
-    tool: async (client, args82, ctx) => {
-      const [result, apiCall] = await issuingTransactionsList(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args85,
+    tool: async (client, args86, ctx) => {
+      const [result, apiCall] = await issuingTransactionsList(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72302,9 +73046,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/issuingTransactionsListAuthorizationEvents.ts
 function issuingTransactionsListAuthorizationEvents(client, request, options) {
-  return new APIPromise($do82(client, request, options));
+  return new APIPromise($do86(client, request, options));
 }
-async function $do82(client, request, options) {
+async function $do86(client, request, options) {
   const parsed = safeParse(request, (value) => ListIssuedCardAuthorizationEventsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72388,12 +73132,12 @@ var init_issuingTransactionsListAuthorizationEvents = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsListAuthorizationEvents.ts
-var args82, tool$issuingTransactionsListAuthorizationEvents;
+var args86, tool$issuingTransactionsListAuthorizationEvents;
 var init_issuingTransactionsListAuthorizationEvents2 = __esm(() => {
   init_issuingTransactionsListAuthorizationEvents();
   init_operations();
   init_tools();
-  args82 = {
+  args86 = {
     request: ListIssuedCardAuthorizationEventsRequest$inboundSchema
   };
   tool$issuingTransactionsListAuthorizationEvents = {
@@ -72402,9 +73146,9 @@ var init_issuingTransactionsListAuthorizationEvents2 = __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}/issued-cards.read\` scope.`,
-    args: args82,
-    tool: async (client, args83, ctx) => {
-      const [result, apiCall] = await issuingTransactionsListAuthorizationEvents(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args86,
+    tool: async (client, args87, ctx) => {
+      const [result, apiCall] = await issuingTransactionsListAuthorizationEvents(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72419,9 +73163,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/issuingTransactionsListAuthorizations.ts
 function issuingTransactionsListAuthorizations(client, request, options) {
-  return new APIPromise($do83(client, request, options));
+  return new APIPromise($do87(client, request, options));
 }
-async function $do83(client, request, options) {
+async function $do87(client, request, options) {
   const parsed = safeParse(request, (value) => ListIssuedCardAuthorizationsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72508,12 +73252,12 @@ var init_issuingTransactionsListAuthorizations = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsListAuthorizations.ts
-var args83, tool$issuingTransactionsListAuthorizations;
+var args87, tool$issuingTransactionsListAuthorizations;
 var init_issuingTransactionsListAuthorizations2 = __esm(() => {
   init_issuingTransactionsListAuthorizations();
   init_operations();
   init_tools();
-  args83 = {
+  args87 = {
     request: ListIssuedCardAuthorizationsRequest$inboundSchema
   };
   tool$issuingTransactionsListAuthorizations = {
@@ -72522,9 +73266,9 @@ var init_issuingTransactionsListAuthorizations2 = __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}/issued-cards.read\` scope.`,
-    args: args83,
-    tool: async (client, args84, ctx) => {
-      const [result, apiCall] = await issuingTransactionsListAuthorizations(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args87,
+    tool: async (client, args88, ctx) => {
+      const [result, apiCall] = await issuingTransactionsListAuthorizations(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72539,9 +73283,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/onboardingCreateInvite.ts
 function onboardingCreateInvite(client, request, options) {
-  return new APIPromise($do84(client, request, options));
+  return new APIPromise($do88(client, request, options));
 }
-async function $do84(client, request, options) {
+async function $do88(client, request, options) {
   const parsed = safeParse(request, (value) => OnboardingInviteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72628,12 +73372,12 @@ var init_onboardingCreateInvite = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingCreateInvite.ts
-var args84, tool$onboardingCreateInvite;
+var args88, tool$onboardingCreateInvite;
 var init_onboardingCreateInvite2 = __esm(() => {
   init_onboardingCreateInvite();
   init_components();
   init_tools();
-  args84 = {
+  args88 = {
     request: OnboardingInviteRequest$inboundSchema
   };
   tool$onboardingCreateInvite = {
@@ -72642,9 +73386,9 @@ var init_onboardingCreateInvite2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts.write\` scope.`,
-    args: args84,
-    tool: async (client, args85, ctx) => {
-      const [result, apiCall] = await onboardingCreateInvite(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args88,
+    tool: async (client, args89, ctx) => {
+      const [result, apiCall] = await onboardingCreateInvite(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72659,9 +73403,9 @@ you'll need to specify the \`/accounts.write\` scope.`,
 
 // src/funcs/onboardingGetInvite.ts
 function onboardingGetInvite(client, request, options) {
-  return new APIPromise($do85(client, request, options));
+  return new APIPromise($do89(client, request, options));
 }
-async function $do85(client, request, options) {
+async function $do89(client, request, options) {
   const parsed = safeParse(request, (value) => GetOnboardingInviteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72739,12 +73483,12 @@ var init_onboardingGetInvite = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingGetInvite.ts
-var args85, tool$onboardingGetInvite;
+var args89, tool$onboardingGetInvite;
 var init_onboardingGetInvite2 = __esm(() => {
   init_onboardingGetInvite();
   init_operations();
   init_tools();
-  args85 = {
+  args89 = {
     request: GetOnboardingInviteRequest$inboundSchema
   };
   tool$onboardingGetInvite = {
@@ -72753,9 +73497,9 @@ var init_onboardingGetInvite2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts.read\` scope.`,
-    args: args85,
-    tool: async (client, args86, ctx) => {
-      const [result, apiCall] = await onboardingGetInvite(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args89,
+    tool: async (client, args90, ctx) => {
+      const [result, apiCall] = await onboardingGetInvite(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72770,9 +73514,9 @@ you'll need to specify the \`/accounts.read\` scope.`,
 
 // src/funcs/onboardingListInvites.ts
 function onboardingListInvites(client, _request, options) {
-  return new APIPromise($do86(client, _request, options));
+  return new APIPromise($do90(client, _request, options));
 }
-async function $do86(client, _request, options) {
+async function $do90(client, _request, options) {
   const path = pathToFunc("/onboarding-invites")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -72836,12 +73580,12 @@ var init_onboardingListInvites = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingListInvites.ts
-var args86, tool$onboardingListInvites;
+var args90, tool$onboardingListInvites;
 var init_onboardingListInvites2 = __esm(() => {
   init_onboardingListInvites();
   init_operations();
   init_tools();
-  args86 = {
+  args90 = {
     request: ListOnboardingInvitesRequest$inboundSchema
   };
   tool$onboardingListInvites = {
@@ -72850,9 +73594,9 @@ var init_onboardingListInvites2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts.read\` scope.`,
-    args: args86,
-    tool: async (client, args87, ctx) => {
-      const [result, apiCall] = await onboardingListInvites(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args90,
+    tool: async (client, args91, ctx) => {
+      const [result, apiCall] = await onboardingListInvites(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72867,9 +73611,9 @@ you'll need to specify the \`/accounts.read\` scope.`,
 
 // src/funcs/onboardingRevokeInvite.ts
 function onboardingRevokeInvite(client, request, options) {
-  return new APIPromise($do87(client, request, options));
+  return new APIPromise($do91(client, request, options));
 }
-async function $do87(client, request, options) {
+async function $do91(client, request, options) {
   const parsed = safeParse(request, (value) => RevokeOnboardingInviteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72944,12 +73688,12 @@ var init_onboardingRevokeInvite = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingRevokeInvite.ts
-var args87, tool$onboardingRevokeInvite;
+var args91, tool$onboardingRevokeInvite;
 var init_onboardingRevokeInvite2 = __esm(() => {
   init_onboardingRevokeInvite();
   init_operations();
   init_tools();
-  args87 = {
+  args91 = {
     request: RevokeOnboardingInviteRequest$inboundSchema
   };
   tool$onboardingRevokeInvite = {
@@ -72958,9 +73702,9 @@ var init_onboardingRevokeInvite2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts.write\` scope.`,
-    args: args87,
-    tool: async (client, args88, ctx) => {
-      const [result, apiCall] = await onboardingRevokeInvite(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args91,
+    tool: async (client, args92, ctx) => {
+      const [result, apiCall] = await onboardingRevokeInvite(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72974,9 +73718,9 @@ you'll need to specify the \`/accounts.write\` scope.`,
 
 // src/funcs/paymentLinksCreate.ts
 function paymentLinksCreate(client, request, options) {
-  return new APIPromise($do88(client, request, options));
+  return new APIPromise($do92(client, request, options));
 }
-async function $do88(client, request, options) {
+async function $do92(client, request, options) {
   const parsed = safeParse(request, (value) => CreatePaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73068,12 +73812,12 @@ var init_paymentLinksCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksCreate.ts
-var args88, tool$paymentLinksCreate;
+var args92, tool$paymentLinksCreate;
 var init_paymentLinksCreate2 = __esm(() => {
   init_paymentLinksCreate();
   init_operations();
   init_tools();
-  args88 = {
+  args92 = {
     request: CreatePaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksCreate = {
@@ -73082,9 +73826,9 @@ var init_paymentLinksCreate2 = __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: args88,
-    tool: async (client, args89, ctx) => {
-      const [result, apiCall] = await paymentLinksCreate(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args92,
+    tool: async (client, args93, ctx) => {
+      const [result, apiCall] = await paymentLinksCreate(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73099,9 +73843,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/paymentLinksDisable.ts
 function paymentLinksDisable(client, request, options) {
-  return new APIPromise($do89(client, request, options));
+  return new APIPromise($do93(client, request, options));
 }
-async function $do89(client, request, options) {
+async function $do93(client, request, options) {
   const parsed = safeParse(request, (value) => DisablePaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73182,12 +73926,12 @@ var init_paymentLinksDisable = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksDisable.ts
-var args89, tool$paymentLinksDisable;
+var args93, tool$paymentLinksDisable;
 var init_paymentLinksDisable2 = __esm(() => {
   init_paymentLinksDisable();
   init_operations();
   init_tools();
-  args89 = {
+  args93 = {
     request: DisablePaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksDisable = {
@@ -73196,9 +73940,9 @@ var init_paymentLinksDisable2 = __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: args89,
-    tool: async (client, args90, ctx) => {
-      const [result, apiCall] = await paymentLinksDisable(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args93,
+    tool: async (client, args94, ctx) => {
+      const [result, apiCall] = await paymentLinksDisable(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73212,9 +73956,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/paymentLinksGet.ts
 function paymentLinksGet(client, request, options) {
-  return new APIPromise($do90(client, request, options));
+  return new APIPromise($do94(client, request, options));
 }
-async function $do90(client, request, options) {
+async function $do94(client, request, options) {
   const parsed = safeParse(request, (value) => GetPaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73296,12 +74040,12 @@ var init_paymentLinksGet = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksGet.ts
-var args90, tool$paymentLinksGet;
+var args94, tool$paymentLinksGet;
 var init_paymentLinksGet2 = __esm(() => {
   init_paymentLinksGet();
   init_operations();
   init_tools();
-  args90 = {
+  args94 = {
     request: GetPaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksGet = {
@@ -73310,9 +74054,9 @@ var init_paymentLinksGet2 = __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: args90,
-    tool: async (client, args91, ctx) => {
-      const [result, apiCall] = await paymentLinksGet(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args94,
+    tool: async (client, args95, ctx) => {
+      const [result, apiCall] = await paymentLinksGet(client, args95.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73327,9 +74071,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/paymentLinksGetQRCode.ts
 function paymentLinksGetQRCode(client, request, options) {
-  return new APIPromise($do91(client, request, options));
+  return new APIPromise($do95(client, request, options));
 }
-async function $do91(client, request, options) {
+async function $do95(client, request, options) {
   const parsed = safeParse(request, (value) => GetPaymentLinkQRCodeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73415,12 +74159,12 @@ var init_paymentLinksGetQRCode = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksGetQRCode.ts
-var args91, tool$paymentLinksGetQRCode;
+var args95, tool$paymentLinksGetQRCode;
 var init_paymentLinksGetQRCode2 = __esm(() => {
   init_paymentLinksGetQRCode();
   init_operations();
   init_tools();
-  args91 = {
+  args95 = {
     request: GetPaymentLinkQRCodeRequest$inboundSchema
   };
   tool$paymentLinksGetQRCode = {
@@ -73431,9 +74175,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}/transfers.write\` scope.`,
-    args: args91,
-    tool: async (client, args92, ctx) => {
-      const [result, apiCall] = await paymentLinksGetQRCode(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args95,
+    tool: async (client, args96, ctx) => {
+      const [result, apiCall] = await paymentLinksGetQRCode(client, args96.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73448,9 +74192,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/paymentLinksList.ts
 function paymentLinksList(client, request, options) {
-  return new APIPromise($do92(client, request, options));
+  return new APIPromise($do96(client, request, options));
 }
-async function $do92(client, request, options) {
+async function $do96(client, request, options) {
   const parsed = safeParse(request, (value) => ListPaymentLinksRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73528,12 +74272,12 @@ var init_paymentLinksList = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksList.ts
-var args92, tool$paymentLinksList;
+var args96, tool$paymentLinksList;
 var init_paymentLinksList2 = __esm(() => {
   init_paymentLinksList();
   init_operations();
   init_tools();
-  args92 = {
+  args96 = {
     request: ListPaymentLinksRequest$inboundSchema
   };
   tool$paymentLinksList = {
@@ -73542,9 +74286,9 @@ var init_paymentLinksList2 = __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: args92,
-    tool: async (client, args93, ctx) => {
-      const [result, apiCall] = await paymentLinksList(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args96,
+    tool: async (client, args97, ctx) => {
+      const [result, apiCall] = await paymentLinksList(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73559,9 +74303,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/paymentLinksUpdate.ts
 function paymentLinksUpdate(client, request, options) {
-  return new APIPromise($do93(client, request, options));
+  return new APIPromise($do97(client, request, options));
 }
-async function $do93(client, request, options) {
+async function $do97(client, request, options) {
   const parsed = safeParse(request, (value) => UpdatePaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73657,12 +74401,12 @@ var init_paymentLinksUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksUpdate.ts
-var args93, tool$paymentLinksUpdate;
+var args97, tool$paymentLinksUpdate;
 var init_paymentLinksUpdate2 = __esm(() => {
   init_paymentLinksUpdate();
   init_operations();
   init_tools();
-  args93 = {
+  args97 = {
     request: UpdatePaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksUpdate = {
@@ -73671,9 +74415,9 @@ var init_paymentLinksUpdate2 = __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: args93,
-    tool: async (client, args94, ctx) => {
-      const [result, apiCall] = await paymentLinksUpdate(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args97,
+    tool: async (client, args98, ctx) => {
+      const [result, apiCall] = await paymentLinksUpdate(client, args98.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73688,9 +74432,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/paymentMethodsGet.ts
 function paymentMethodsGet(client, request, options) {
-  return new APIPromise($do94(client, request, options));
+  return new APIPromise($do98(client, request, options));
 }
-async function $do94(client, request, options) {
+async function $do98(client, request, options) {
   const parsed = safeParse(request, (value) => GetPaymentMethodRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73772,12 +74516,12 @@ var init_paymentMethodsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentMethodsGet.ts
-var args94, tool$paymentMethodsGet;
+var args98, tool$paymentMethodsGet;
 var init_paymentMethodsGet2 = __esm(() => {
   init_paymentMethodsGet();
   init_operations();
   init_tools();
-  args94 = {
+  args98 = {
     request: GetPaymentMethodRequest$inboundSchema
   };
   tool$paymentMethodsGet = {
@@ -73786,9 +74530,9 @@ var init_paymentMethodsGet2 = __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}/payment-methods.read\` scope.`,
-    args: args94,
-    tool: async (client, args95, ctx) => {
-      const [result, apiCall] = await paymentMethodsGet(client, args95.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args98,
+    tool: async (client, args99, ctx) => {
+      const [result, apiCall] = await paymentMethodsGet(client, args99.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73803,9 +74547,9 @@ you'll need to specify the \`/accounts/{accountID}/payment-methods.read\` scope.
 
 // src/funcs/paymentMethodsList.ts
 function paymentMethodsList(client, request, options) {
-  return new APIPromise($do95(client, request, options));
+  return new APIPromise($do99(client, request, options));
 }
-async function $do95(client, request, options) {
+async function $do99(client, request, options) {
   const parsed = safeParse(request, (value) => ListPaymentMethodsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73888,12 +74632,12 @@ var init_paymentMethodsList = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentMethodsList.ts
-var args95, tool$paymentMethodsList;
+var args99, tool$paymentMethodsList;
 var init_paymentMethodsList2 = __esm(() => {
   init_paymentMethodsList();
   init_operations();
   init_tools();
-  args95 = {
+  args99 = {
     request: ListPaymentMethodsRequest$inboundSchema
   };
   tool$paymentMethodsList = {
@@ -73903,9 +74647,9 @@ guide](https://docs.moov.io/guides/money-movement/payment-methods/) to learn mor
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/payment-methods.read\` scope.`,
-    args: args95,
-    tool: async (client, args96, ctx) => {
-      const [result, apiCall] = await paymentMethodsList(client, args96.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args99,
+    tool: async (client, args100, ctx) => {
+      const [result, apiCall] = await paymentMethodsList(client, args100.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73920,9 +74664,9 @@ you'll need to specify the \`/accounts/{accountID}/payment-methods.read\` scope.
 
 // src/funcs/pingPing.ts
 function pingPing(client, _request, options) {
-  return new APIPromise($do96(client, _request, options));
+  return new APIPromise($do100(client, _request, options));
 }
-async function $do96(client, _request, options) {
+async function $do100(client, _request, options) {
   const path = pathToFunc("/ping")();
   const headers = new Headers(compactMap({
     Accept: "*/*",
@@ -73985,12 +74729,12 @@ var init_pingPing = __esm(() => {
 });
 
 // src/mcp-server/tools/pingPing.ts
-var args96, tool$pingPing;
+var args100, tool$pingPing;
 var init_pingPing2 = __esm(() => {
   init_pingPing();
   init_operations();
   init_tools();
-  args96 = {
+  args100 = {
     request: PingRequest$inboundSchema
   };
   tool$pingPing = {
@@ -73999,9 +74743,9 @@ var init_pingPing2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/ping.read\` scope.`,
-    args: args96,
-    tool: async (client, args97, ctx) => {
-      const [result, apiCall] = await pingPing(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args100,
+    tool: async (client, args101, ctx) => {
+      const [result, apiCall] = await pingPing(client, args101.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74015,9 +74759,9 @@ you'll need to specify the \`/ping.read\` scope.`,
 
 // src/funcs/receiptsCreate.ts
 function receiptsCreate(client, request, options) {
-  return new APIPromise($do97(client, request, options));
+  return new APIPromise($do101(client, request, options));
 }
-async function $do97(client, request, options) {
+async function $do101(client, request, options) {
   const parsed = safeParse(request, (value) => arrayType(ReceiptRequest$outboundSchema).parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74105,13 +74849,13 @@ var init_receiptsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/receiptsCreate.ts
-var args97, tool$receiptsCreate;
+var args101, tool$receiptsCreate;
 var init_receiptsCreate2 = __esm(() => {
   init_esm();
   init_receiptsCreate();
   init_components();
   init_tools();
-  args97 = {
+  args101 = {
     request: arrayType(ReceiptRequest$inboundSchema)
   };
   tool$receiptsCreate = {
@@ -74120,9 +74864,9 @@ var init_receiptsCreate2 = __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: args97,
-    tool: async (client, args98, ctx) => {
-      const [result, apiCall] = await receiptsCreate(client, args98.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args101,
+    tool: async (client, args102, ctx) => {
+      const [result, apiCall] = await receiptsCreate(client, args102.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74137,9 +74881,9 @@ var init_receiptsCreate2 = __esm(() => {
 
 // src/funcs/receiptsList.ts
 function receiptsList(client, request, options) {
-  return new APIPromise($do98(client, request, options));
+  return new APIPromise($do102(client, request, options));
 }
-async function $do98(client, request, options) {
+async function $do102(client, request, options) {
   const parsed = safeParse(request, (value) => ListReceiptsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74215,12 +74959,12 @@ var init_receiptsList = __esm(() => {
 });
 
 // src/mcp-server/tools/receiptsList.ts
-var args98, tool$receiptsList;
+var args102, tool$receiptsList;
 var init_receiptsList2 = __esm(() => {
   init_receiptsList();
   init_operations();
   init_tools();
-  args98 = {
+  args102 = {
     request: ListReceiptsRequest$inboundSchema
   };
   tool$receiptsList = {
@@ -74229,9 +74973,9 @@ var init_receiptsList2 = __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: args98,
-    tool: async (client, args99, ctx) => {
-      const [result, apiCall] = await receiptsList(client, args99.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args102,
+    tool: async (client, args103, ctx) => {
+      const [result, apiCall] = await receiptsList(client, args103.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74246,9 +74990,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/representativesCreate.ts
 function representativesCreate(client, request, options) {
-  return new APIPromise($do99(client, request, options));
+  return new APIPromise($do103(client, request, options));
 }
-async function $do99(client, request, options) {
+async function $do103(client, request, options) {
   const parsed = safeParse(request, (value) => CreateRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74344,12 +75088,12 @@ var init_representativesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesCreate.ts
-var args99, tool$representativesCreate;
+var args103, tool$representativesCreate;
 var init_representativesCreate2 = __esm(() => {
   init_representativesCreate();
   init_operations();
   init_tools();
-  args99 = {
+  args103 = {
     request: CreateRepresentativeRequest$inboundSchema
   };
   tool$representativesCreate = {
@@ -74360,9 +75104,9 @@ Read our [business representatives guide](https://docs.moov.io/guides/accounts/r
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope.`,
-    args: args99,
-    tool: async (client, args100, ctx) => {
-      const [result, apiCall] = await representativesCreate(client, args100.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args103,
+    tool: async (client, args104, ctx) => {
+      const [result, apiCall] = await representativesCreate(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74377,9 +75121,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/representativesDelete.ts
 function representativesDelete(client, request, options) {
-  return new APIPromise($do100(client, request, options));
+  return new APIPromise($do104(client, request, options));
 }
-async function $do100(client, request, options) {
+async function $do104(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74467,12 +75211,12 @@ var init_representativesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesDelete.ts
-var args100, tool$representativesDelete;
+var args104, tool$representativesDelete;
 var init_representativesDelete2 = __esm(() => {
   init_representativesDelete();
   init_operations();
   init_tools();
-  args100 = {
+  args104 = {
     request: DeleteRepresentativeRequest$inboundSchema
   };
   tool$representativesDelete = {
@@ -74481,9 +75225,9 @@ var init_representativesDelete2 = __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}/representatives.write\` scope.`,
-    args: args100,
-    tool: async (client, args101, ctx) => {
-      const [result, apiCall] = await representativesDelete(client, args101.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args104,
+    tool: async (client, args105, ctx) => {
+      const [result, apiCall] = await representativesDelete(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74497,9 +75241,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/representativesGet.ts
 function representativesGet(client, request, options) {
-  return new APIPromise($do101(client, request, options));
+  return new APIPromise($do105(client, request, options));
 }
-async function $do101(client, request, options) {
+async function $do105(client, request, options) {
   const parsed = safeParse(request, (value) => GetRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74578,12 +75322,12 @@ var init_representativesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesGet.ts
-var args101, tool$representativesGet;
+var args105, tool$representativesGet;
 var init_representativesGet2 = __esm(() => {
   init_representativesGet();
   init_operations();
   init_tools();
-  args101 = {
+  args105 = {
     request: GetRepresentativeRequest$inboundSchema
   };
   tool$representativesGet = {
@@ -74592,9 +75336,9 @@ var init_representativesGet2 = __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}/representatives.read\` scope.`,
-    args: args101,
-    tool: async (client, args102, ctx) => {
-      const [result, apiCall] = await representativesGet(client, args102.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args105,
+    tool: async (client, args106, ctx) => {
+      const [result, apiCall] = await representativesGet(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74609,9 +75353,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.read\` scope.
 
 // src/funcs/representativesList.ts
 function representativesList(client, request, options) {
-  return new APIPromise($do102(client, request, options));
+  return new APIPromise($do106(client, request, options));
 }
-async function $do102(client, request, options) {
+async function $do106(client, request, options) {
   const parsed = safeParse(request, (value) => ListRepresentativesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74689,12 +75433,12 @@ var init_representativesList = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesList.ts
-var args102, tool$representativesList;
+var args106, tool$representativesList;
 var init_representativesList2 = __esm(() => {
   init_representativesList();
   init_operations();
   init_tools();
-  args102 = {
+  args106 = {
     request: ListRepresentativesRequest$inboundSchema
   };
   tool$representativesList = {
@@ -74706,9 +75450,9 @@ Read our [business representatives guide](https://docs.moov.io/guides/accounts/r
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/representatives.read\` scope.`,
-    args: args102,
-    tool: async (client, args103, ctx) => {
-      const [result, apiCall] = await representativesList(client, args103.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args106,
+    tool: async (client, args107, ctx) => {
+      const [result, apiCall] = await representativesList(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74723,9 +75467,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.read\` scope.
 
 // src/funcs/representativesUpdate.ts
 function representativesUpdate(client, request, options) {
-  return new APIPromise($do103(client, request, options));
+  return new APIPromise($do107(client, request, options));
 }
-async function $do103(client, request, options) {
+async function $do107(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74819,12 +75563,12 @@ var init_representativesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesUpdate.ts
-var args103, tool$representativesUpdate;
+var args107, tool$representativesUpdate;
 var init_representativesUpdate2 = __esm(() => {
   init_representativesUpdate();
   init_operations();
   init_tools();
-  args103 = {
+  args107 = {
     request: UpdateRepresentativeRequest$inboundSchema
   };
   tool$representativesUpdate = {
@@ -74846,9 +75590,9 @@ If you need to update information in a locked state, please contact Moov support
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope.`,
-    args: args103,
-    tool: async (client, args104, ctx) => {
-      const [result, apiCall] = await representativesUpdate(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args107,
+    tool: async (client, args108, ctx) => {
+      const [result, apiCall] = await representativesUpdate(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74863,9 +75607,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/schedulingCancel.ts
 function schedulingCancel(client, request, options) {
-  return new APIPromise($do104(client, request, options));
+  return new APIPromise($do108(client, request, options));
 }
-async function $do104(client, request, options) {
+async function $do108(client, request, options) {
   const parsed = safeParse(request, (value) => CancelScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74958,12 +75702,12 @@ var init_schedulingCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingCancel.ts
-var args104, tool$schedulingCancel;
+var args108, tool$schedulingCancel;
 var init_schedulingCancel2 = __esm(() => {
   init_schedulingCancel();
   init_operations();
   init_tools();
-  args104 = {
+  args108 = {
     request: CancelScheduleRequest$inboundSchema
   };
   tool$schedulingCancel = {
@@ -74972,9 +75716,9 @@ var init_schedulingCancel2 = __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: args104,
-    tool: async (client, args105, ctx) => {
-      const [result, apiCall] = await schedulingCancel(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args108,
+    tool: async (client, args109, ctx) => {
+      const [result, apiCall] = await schedulingCancel(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74988,9 +75732,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/schedulingCreate.ts
 function schedulingCreate(client, request, options) {
-  return new APIPromise($do105(client, request, options));
+  return new APIPromise($do109(client, request, options));
 }
-async function $do105(client, request, options) {
+async function $do109(client, request, options) {
   const parsed = safeParse(request, (value) => CreateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75084,12 +75828,12 @@ var init_schedulingCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingCreate.ts
-var args105, tool$schedulingCreate;
+var args109, tool$schedulingCreate;
 var init_schedulingCreate2 = __esm(() => {
   init_schedulingCreate();
   init_operations();
   init_tools();
-  args105 = {
+  args109 = {
     request: CreateScheduleRequest$inboundSchema
   };
   tool$schedulingCreate = {
@@ -75098,9 +75842,9 @@ var init_schedulingCreate2 = __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: args105,
-    tool: async (client, args106, ctx) => {
-      const [result, apiCall] = await schedulingCreate(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args109,
+    tool: async (client, args110, ctx) => {
+      const [result, apiCall] = await schedulingCreate(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75115,9 +75859,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/schedulingGet.ts
 function schedulingGet(client, request, options) {
-  return new APIPromise($do106(client, request, options));
+  return new APIPromise($do110(client, request, options));
 }
-async function $do106(client, request, options) {
+async function $do110(client, request, options) {
   const parsed = safeParse(request, (value) => GetSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75199,12 +75943,12 @@ var init_schedulingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingGet.ts
-var args106, tool$schedulingGet;
+var args110, tool$schedulingGet;
 var init_schedulingGet2 = __esm(() => {
   init_schedulingGet();
   init_operations();
   init_tools();
-  args106 = {
+  args110 = {
     request: GetSchedulesRequest$inboundSchema
   };
   tool$schedulingGet = {
@@ -75213,9 +75957,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: args106,
-    tool: async (client, args107, ctx) => {
-      const [result, apiCall] = await schedulingGet(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args110,
+    tool: async (client, args111, ctx) => {
+      const [result, apiCall] = await schedulingGet(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75230,9 +75974,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingGetOccurrance.ts
 function schedulingGetOccurrance(client, request, options) {
-  return new APIPromise($do107(client, request, options));
+  return new APIPromise($do111(client, request, options));
 }
-async function $do107(client, request, options) {
+async function $do111(client, request, options) {
   const parsed = safeParse(request, (value) => GetScheduledOccurrenceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75315,12 +76059,12 @@ var init_schedulingGetOccurrance = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingGetOccurrance.ts
-var args107, tool$schedulingGetOccurrance;
+var args111, tool$schedulingGetOccurrance;
 var init_schedulingGetOccurrance2 = __esm(() => {
   init_schedulingGetOccurrance();
   init_operations();
   init_tools();
-  args107 = {
+  args111 = {
     request: GetScheduledOccurrenceRequest$inboundSchema
   };
   tool$schedulingGetOccurrance = {
@@ -75329,9 +76073,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: args107,
-    tool: async (client, args108, ctx) => {
-      const [result, apiCall] = await schedulingGetOccurrance(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args111,
+    tool: async (client, args112, ctx) => {
+      const [result, apiCall] = await schedulingGetOccurrance(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75346,9 +76090,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingList.ts
 function schedulingList(client, request, options) {
-  return new APIPromise($do108(client, request, options));
+  return new APIPromise($do112(client, request, options));
 }
-async function $do108(client, request, options) {
+async function $do112(client, request, options) {
   const parsed = safeParse(request, (value) => ListSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75432,12 +76176,12 @@ var init_schedulingList = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingList.ts
-var args108, tool$schedulingList;
+var args112, tool$schedulingList;
 var init_schedulingList2 = __esm(() => {
   init_schedulingList();
   init_operations();
   init_tools();
-  args108 = {
+  args112 = {
     request: ListSchedulesRequest$inboundSchema
   };
   tool$schedulingList = {
@@ -75446,9 +76190,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: args108,
-    tool: async (client, args109, ctx) => {
-      const [result, apiCall] = await schedulingList(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args112,
+    tool: async (client, args113, ctx) => {
+      const [result, apiCall] = await schedulingList(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75463,9 +76207,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingUpdate.ts
 function schedulingUpdate(client, request, options) {
-  return new APIPromise($do109(client, request, options));
+  return new APIPromise($do113(client, request, options));
 }
-async function $do109(client, request, options) {
+async function $do113(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75563,12 +76307,12 @@ var init_schedulingUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingUpdate.ts
-var args109, tool$schedulingUpdate;
+var args113, tool$schedulingUpdate;
 var init_schedulingUpdate2 = __esm(() => {
   init_schedulingUpdate();
   init_operations();
   init_tools();
-  args109 = {
+  args113 = {
     request: UpdateScheduleRequest$inboundSchema
   };
   tool$schedulingUpdate = {
@@ -75577,9 +76321,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: args109,
-    tool: async (client, args110, ctx) => {
-      const [result, apiCall] = await schedulingUpdate(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args113,
+    tool: async (client, args114, ctx) => {
+      const [result, apiCall] = await schedulingUpdate(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75594,9 +76338,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/statementsGet.ts
 function statementsGet(client, request, options) {
-  return new APIPromise($do110(client, request, options));
+  return new APIPromise($do114(client, request, options));
 }
-async function $do110(client, request, options) {
+async function $do114(client, request, options) {
   const parsed = safeParse(request, (value) => GetStatementRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75682,12 +76426,12 @@ var init_statementsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/statementsGet.ts
-var args110, tool$statementsGet;
+var args114, tool$statementsGet;
 var init_statementsGet2 = __esm(() => {
   init_statementsGet();
   init_operations();
   init_tools();
-  args110 = {
+  args114 = {
     request: GetStatementRequest$inboundSchema
   };
   tool$statementsGet = {
@@ -75698,9 +76442,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: args110,
-    tool: async (client, args111, ctx) => {
-      const [result, apiCall] = await statementsGet(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args114,
+    tool: async (client, args115, ctx) => {
+      const [result, apiCall] = await statementsGet(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75715,9 +76459,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/statementsList.ts
 function statementsList(client, request, options) {
-  return new APIPromise($do111(client, request, options));
+  return new APIPromise($do115(client, request, options));
 }
-async function $do111(client, request, options) {
+async function $do115(client, request, options) {
   const parsed = safeParse(request, (value) => ListStatementsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75803,12 +76547,12 @@ var init_statementsList = __esm(() => {
 });
 
 // src/mcp-server/tools/statementsList.ts
-var args111, tool$statementsList;
+var args115, tool$statementsList;
 var init_statementsList2 = __esm(() => {
   init_statementsList();
   init_operations();
   init_tools();
-  args111 = {
+  args115 = {
     request: ListStatementsRequest$inboundSchema
   };
   tool$statementsList = {
@@ -75817,9 +76561,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: args111,
-    tool: async (client, args112, ctx) => {
-      const [result, apiCall] = await statementsList(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args115,
+    tool: async (client, args116, ctx) => {
+      const [result, apiCall] = await statementsList(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75834,9 +76578,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/supportCreateTicket.ts
 function supportCreateTicket(client, request, options) {
-  return new APIPromise($do112(client, request, options));
+  return new APIPromise($do116(client, request, options));
 }
-async function $do112(client, request, options) {
+async function $do116(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75928,12 +76672,12 @@ var init_supportCreateTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportCreateTicket.ts
-var args112, tool$supportCreateTicket;
+var args116, tool$supportCreateTicket;
 var init_supportCreateTicket2 = __esm(() => {
   init_supportCreateTicket();
   init_operations();
   init_tools();
-  args112 = {
+  args116 = {
     request: CreateTicketRequest$inboundSchema
   };
   tool$supportCreateTicket = {
@@ -75945,9 +76689,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: args112,
-    tool: async (client, args113, ctx) => {
-      const [result, apiCall] = await supportCreateTicket(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args116,
+    tool: async (client, args117, ctx) => {
+      const [result, apiCall] = await supportCreateTicket(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75962,9 +76706,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{acco
 
 // src/funcs/supportGetTicket.ts
 function supportGetTicket(client, request, options) {
-  return new APIPromise($do113(client, request, options));
+  return new APIPromise($do117(client, request, options));
 }
-async function $do113(client, request, options) {
+async function $do117(client, request, options) {
   const parsed = safeParse(request, (value) => GetTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76046,12 +76790,12 @@ var init_supportGetTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportGetTicket.ts
-var args113, tool$supportGetTicket;
+var args117, tool$supportGetTicket;
 var init_supportGetTicket2 = __esm(() => {
   init_supportGetTicket();
   init_operations();
   init_tools();
-  args113 = {
+  args117 = {
     request: GetTicketRequest$inboundSchema
   };
   tool$supportGetTicket = {
@@ -76063,9 +76807,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: args113,
-    tool: async (client, args114, ctx) => {
-      const [result, apiCall] = await supportGetTicket(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args117,
+    tool: async (client, args118, ctx) => {
+      const [result, apiCall] = await supportGetTicket(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76080,9 +76824,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportListTicketMessages.ts
 function supportListTicketMessages(client, request, options) {
-  return new APIPromise($do114(client, request, options));
+  return new APIPromise($do118(client, request, options));
 }
-async function $do114(client, request, options) {
+async function $do118(client, request, options) {
   const parsed = safeParse(request, (value) => ListTicketMessagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76164,12 +76908,12 @@ var init_supportListTicketMessages = __esm(() => {
 });
 
 // src/mcp-server/tools/supportListTicketMessages.ts
-var args114, tool$supportListTicketMessages;
+var args118, tool$supportListTicketMessages;
 var init_supportListTicketMessages2 = __esm(() => {
   init_supportListTicketMessages();
   init_operations();
   init_tools();
-  args114 = {
+  args118 = {
     request: ListTicketMessagesRequest$inboundSchema
   };
   tool$supportListTicketMessages = {
@@ -76181,9 +76925,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: args114,
-    tool: async (client, args115, ctx) => {
-      const [result, apiCall] = await supportListTicketMessages(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args118,
+    tool: async (client, args119, ctx) => {
+      const [result, apiCall] = await supportListTicketMessages(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76198,9 +76942,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportListTickets.ts
 function supportListTickets(client, request, options) {
-  return new APIPromise($do115(client, request, options));
+  return new APIPromise($do119(client, request, options));
 }
-async function $do115(client, request, options) {
+async function $do119(client, request, options) {
   const parsed = safeParse(request, (value) => ListTicketsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76285,12 +77029,12 @@ var init_supportListTickets = __esm(() => {
 });
 
 // src/mcp-server/tools/supportListTickets.ts
-var args115, tool$supportListTickets;
+var args119, tool$supportListTickets;
 var init_supportListTickets2 = __esm(() => {
   init_supportListTickets();
   init_operations();
   init_tools();
-  args115 = {
+  args119 = {
     request: ListTicketsRequest$inboundSchema
   };
   tool$supportListTickets = {
@@ -76302,9 +77046,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: args115,
-    tool: async (client, args116, ctx) => {
-      const [result, apiCall] = await supportListTickets(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args119,
+    tool: async (client, args120, ctx) => {
+      const [result, apiCall] = await supportListTickets(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76319,9 +77063,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportUpdateTicket.ts
 function supportUpdateTicket(client, request, options) {
-  return new APIPromise($do116(client, request, options));
+  return new APIPromise($do120(client, request, options));
 }
-async function $do116(client, request, options) {
+async function $do120(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76417,12 +77161,12 @@ var init_supportUpdateTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportUpdateTicket.ts
-var args116, tool$supportUpdateTicket;
+var args120, tool$supportUpdateTicket;
 var init_supportUpdateTicket2 = __esm(() => {
   init_supportUpdateTicket();
   init_operations();
   init_tools();
-  args116 = {
+  args120 = {
     request: UpdateTicketRequest$inboundSchema
   };
   tool$supportUpdateTicket = {
@@ -76434,9 +77178,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: args116,
-    tool: async (client, args117, ctx) => {
-      const [result, apiCall] = await supportUpdateTicket(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args120,
+    tool: async (client, args121, ctx) => {
+      const [result, apiCall] = await supportUpdateTicket(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76451,9 +77195,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{acco
 
 // src/funcs/sweepsCreateConfig.ts
 function sweepsCreateConfig(client, request, options) {
-  return new APIPromise($do117(client, request, options));
+  return new APIPromise($do121(client, request, options));
 }
-async function $do117(client, request, options) {
+async function $do121(client, request, options) {
   const parsed = safeParse(request, (value) => CreateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76545,12 +77289,12 @@ var init_sweepsCreateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsCreateConfig.ts
-var args117, tool$sweepsCreateConfig;
+var args121, tool$sweepsCreateConfig;
 var init_sweepsCreateConfig2 = __esm(() => {
   init_sweepsCreateConfig();
   init_operations();
   init_tools();
-  args117 = {
+  args121 = {
     request: CreateSweepConfigRequest$inboundSchema
   };
   tool$sweepsCreateConfig = {
@@ -76559,9 +77303,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: args117,
-    tool: async (client, args118, ctx) => {
-      const [result, apiCall] = await sweepsCreateConfig(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args121,
+    tool: async (client, args122, ctx) => {
+      const [result, apiCall] = await sweepsCreateConfig(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76576,9 +77320,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/sweepsGet.ts
 function sweepsGet(client, request, options) {
-  return new APIPromise($do118(client, request, options));
+  return new APIPromise($do122(client, request, options));
 }
-async function $do118(client, request, options) {
+async function $do122(client, request, options) {
   const parsed = safeParse(request, (value) => GetSweepRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76664,12 +77408,12 @@ var init_sweepsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGet.ts
-var args118, tool$sweepsGet;
+var args122, tool$sweepsGet;
 var init_sweepsGet2 = __esm(() => {
   init_sweepsGet();
   init_operations();
   init_tools();
-  args118 = {
+  args122 = {
     request: GetSweepRequest$inboundSchema
   };
   tool$sweepsGet = {
@@ -76678,9 +77422,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: args118,
-    tool: async (client, args119, ctx) => {
-      const [result, apiCall] = await sweepsGet(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args122,
+    tool: async (client, args123, ctx) => {
+      const [result, apiCall] = await sweepsGet(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76695,9 +77439,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsGetConfig.ts
 function sweepsGetConfig(client, request, options) {
-  return new APIPromise($do119(client, request, options));
+  return new APIPromise($do123(client, request, options));
 }
-async function $do119(client, request, options) {
+async function $do123(client, request, options) {
   const parsed = safeParse(request, (value) => GetSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76779,12 +77523,12 @@ var init_sweepsGetConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGetConfig.ts
-var args119, tool$sweepsGetConfig;
+var args123, tool$sweepsGetConfig;
 var init_sweepsGetConfig2 = __esm(() => {
   init_sweepsGetConfig();
   init_operations();
   init_tools();
-  args119 = {
+  args123 = {
     request: GetSweepConfigRequest$inboundSchema
   };
   tool$sweepsGetConfig = {
@@ -76793,9 +77537,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: args119,
-    tool: async (client, args120, ctx) => {
-      const [result, apiCall] = await sweepsGetConfig(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args123,
+    tool: async (client, args124, ctx) => {
+      const [result, apiCall] = await sweepsGetConfig(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76810,9 +77554,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsList.ts
 function sweepsList(client, request, options) {
-  return new APIPromise($do120(client, request, options));
+  return new APIPromise($do124(client, request, options));
 }
-async function $do120(client, request, options) {
+async function $do124(client, request, options) {
   const parsed = safeParse(request, (value) => ListSweepsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76901,12 +77645,12 @@ var init_sweepsList = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsList.ts
-var args120, tool$sweepsList;
+var args124, tool$sweepsList;
 var init_sweepsList2 = __esm(() => {
   init_sweepsList();
   init_operations();
   init_tools();
-  args120 = {
+  args124 = {
     request: ListSweepsRequest$inboundSchema
   };
   tool$sweepsList = {
@@ -76915,9 +77659,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: args120,
-    tool: async (client, args121, ctx) => {
-      const [result, apiCall] = await sweepsList(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args124,
+    tool: async (client, args125, ctx) => {
+      const [result, apiCall] = await sweepsList(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76932,9 +77676,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsListConfigs.ts
 function sweepsListConfigs(client, request, options) {
-  return new APIPromise($do121(client, request, options));
+  return new APIPromise($do125(client, request, options));
 }
-async function $do121(client, request, options) {
+async function $do125(client, request, options) {
   const parsed = safeParse(request, (value) => ListSweepConfigsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77012,12 +77756,12 @@ var init_sweepsListConfigs = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsListConfigs.ts
-var args121, tool$sweepsListConfigs;
+var args125, tool$sweepsListConfigs;
 var init_sweepsListConfigs2 = __esm(() => {
   init_sweepsListConfigs();
   init_operations();
   init_tools();
-  args121 = {
+  args125 = {
     request: ListSweepConfigsRequest$inboundSchema
   };
   tool$sweepsListConfigs = {
@@ -77026,9 +77770,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: args121,
-    tool: async (client, args122, ctx) => {
-      const [result, apiCall] = await sweepsListConfigs(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args125,
+    tool: async (client, args126, ctx) => {
+      const [result, apiCall] = await sweepsListConfigs(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77043,9 +77787,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsUpdateConfig.ts
 function sweepsUpdateConfig(client, request, options) {
-  return new APIPromise($do122(client, request, options));
+  return new APIPromise($do126(client, request, options));
 }
-async function $do122(client, request, options) {
+async function $do126(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77141,12 +77885,12 @@ var init_sweepsUpdateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsUpdateConfig.ts
-var args122, tool$sweepsUpdateConfig;
+var args126, tool$sweepsUpdateConfig;
 var init_sweepsUpdateConfig2 = __esm(() => {
   init_sweepsUpdateConfig();
   init_operations();
   init_tools();
-  args122 = {
+  args126 = {
     request: UpdateSweepConfigRequest$inboundSchema
   };
   tool$sweepsUpdateConfig = {
@@ -77155,9 +77899,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: args122,
-    tool: async (client, args123, ctx) => {
-      const [result, apiCall] = await sweepsUpdateConfig(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args126,
+    tool: async (client, args127, ctx) => {
+      const [result, apiCall] = await sweepsUpdateConfig(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77172,9 +77916,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreate.ts
 function terminalApplicationsCreate(client, request, options) {
-  return new APIPromise($do123(client, request, options));
+  return new APIPromise($do127(client, request, options));
 }
-async function $do123(client, request, options) {
+async function $do127(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTerminalApplication$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77263,12 +78007,12 @@ var init_terminalApplicationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreate.ts
-var args123, tool$terminalApplicationsCreate;
+var args127, tool$terminalApplicationsCreate;
 var init_terminalApplicationsCreate2 = __esm(() => {
   init_terminalApplicationsCreate();
   init_components();
   init_tools();
-  args123 = {
+  args127 = {
     request: CreateTerminalApplication$inboundSchema
   };
   tool$terminalApplicationsCreate = {
@@ -77277,9 +78021,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: args123,
-    tool: async (client, args124, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreate(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args127,
+    tool: async (client, args128, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreate(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77294,9 +78038,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreateVersion.ts
 function terminalApplicationsCreateVersion(client, request, options) {
-  return new APIPromise($do124(client, request, options));
+  return new APIPromise($do128(client, request, options));
 }
-async function $do124(client, request, options) {
+async function $do128(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTerminalApplicationVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77386,12 +78130,12 @@ var init_terminalApplicationsCreateVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreateVersion.ts
-var args124, tool$terminalApplicationsCreateVersion;
+var args128, tool$terminalApplicationsCreateVersion;
 var init_terminalApplicationsCreateVersion2 = __esm(() => {
   init_terminalApplicationsCreateVersion();
   init_operations();
   init_tools();
-  args124 = {
+  args128 = {
     request: CreateTerminalApplicationVersionRequest$inboundSchema
   };
   tool$terminalApplicationsCreateVersion = {
@@ -77400,9 +78144,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: args124,
-    tool: async (client, args125, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args128,
+    tool: async (client, args129, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77417,9 +78161,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsDelete.ts
 function terminalApplicationsDelete(client, request, options) {
-  return new APIPromise($do125(client, request, options));
+  return new APIPromise($do129(client, request, options));
 }
-async function $do125(client, request, options) {
+async function $do129(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77503,12 +78247,12 @@ var init_terminalApplicationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsDelete.ts
-var args125, tool$terminalApplicationsDelete;
+var args129, tool$terminalApplicationsDelete;
 var init_terminalApplicationsDelete2 = __esm(() => {
   init_terminalApplicationsDelete();
   init_operations();
   init_tools();
-  args125 = {
+  args129 = {
     request: DeleteTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsDelete = {
@@ -77517,9 +78261,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: args125,
-    tool: async (client, args126, ctx) => {
-      const [result, apiCall] = await terminalApplicationsDelete(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args129,
+    tool: async (client, args130, ctx) => {
+      const [result, apiCall] = await terminalApplicationsDelete(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77533,9 +78277,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsGet.ts
 function terminalApplicationsGet(client, request, options) {
-  return new APIPromise($do126(client, request, options));
+  return new APIPromise($do130(client, request, options));
 }
-async function $do126(client, request, options) {
+async function $do130(client, request, options) {
   const parsed = safeParse(request, (value) => GetTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77610,12 +78354,12 @@ var init_terminalApplicationsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsGet.ts
-var args126, tool$terminalApplicationsGet;
+var args130, tool$terminalApplicationsGet;
 var init_terminalApplicationsGet2 = __esm(() => {
   init_terminalApplicationsGet();
   init_operations();
   init_tools();
-  args126 = {
+  args130 = {
     request: GetTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsGet = {
@@ -77624,9 +78368,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: args126,
-    tool: async (client, args127, ctx) => {
-      const [result, apiCall] = await terminalApplicationsGet(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args130,
+    tool: async (client, args131, ctx) => {
+      const [result, apiCall] = await terminalApplicationsGet(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77641,9 +78385,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/terminalApplicationsList.ts
 function terminalApplicationsList(client, _request, options) {
-  return new APIPromise($do127(client, _request, options));
+  return new APIPromise($do131(client, _request, options));
 }
-async function $do127(client, _request, options) {
+async function $do131(client, _request, options) {
   const path = pathToFunc("/terminal-applications")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -77707,12 +78451,12 @@ var init_terminalApplicationsList = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsList.ts
-var args127, tool$terminalApplicationsList;
+var args131, tool$terminalApplicationsList;
 var init_terminalApplicationsList2 = __esm(() => {
   init_terminalApplicationsList();
   init_operations();
   init_tools();
-  args127 = {
+  args131 = {
     request: ListTerminalApplicationsRequest$inboundSchema
   };
   tool$terminalApplicationsList = {
@@ -77721,9 +78465,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: args127,
-    tool: async (client, args128, ctx) => {
-      const [result, apiCall] = await terminalApplicationsList(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args131,
+    tool: async (client, args132, ctx) => {
+      const [result, apiCall] = await terminalApplicationsList(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77738,9 +78482,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/transfersCreate.ts
 function transfersCreate(client, request, options) {
-  return new APIPromise($do128(client, request, options));
+  return new APIPromise($do132(client, request, options));
 }
-async function $do128(client, request, options) {
+async function $do132(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77833,12 +78577,12 @@ var init_transfersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreate.ts
-var args128, tool$transfersCreate;
+var args132, tool$transfersCreate;
 var init_transfersCreate2 = __esm(() => {
   init_transfersCreate();
   init_operations();
   init_tools();
-  args128 = {
+  args132 = {
     request: CreateTransferRequest$inboundSchema
   };
   tool$transfersCreate = {
@@ -77849,9 +78593,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: args128,
-    tool: async (client, args129, ctx) => {
-      const [result, apiCall] = await transfersCreate(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args132,
+    tool: async (client, args133, ctx) => {
+      const [result, apiCall] = await transfersCreate(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77866,9 +78610,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersCreateCancellation.ts
 function transfersCreateCancellation(client, request, options) {
-  return new APIPromise($do129(client, request, options));
+  return new APIPromise($do133(client, request, options));
 }
-async function $do129(client, request, options) {
+async function $do133(client, request, options) {
   const parsed = safeParse(request, (value) => CreateCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77951,12 +78695,12 @@ var init_transfersCreateCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateCancellation.ts
-var args129, tool$transfersCreateCancellation;
+var args133, tool$transfersCreateCancellation;
 var init_transfersCreateCancellation2 = __esm(() => {
   init_transfersCreateCancellation();
   init_operations();
   init_tools();
-  args129 = {
+  args133 = {
     request: CreateCancellationRequest$inboundSchema
   };
   tool$transfersCreateCancellation = {
@@ -77965,9 +78709,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: args129,
-    tool: async (client, args130, ctx) => {
-      const [result, apiCall] = await transfersCreateCancellation(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await transfersCreateCancellation(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77982,9 +78726,9 @@ var init_transfersCreateCancellation2 = __esm(() => {
 
 // src/funcs/transfersCreateReversal.ts
 function transfersCreateReversal(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 = safeParse(request, (value) => CreateReversalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78083,12 +78827,12 @@ var init_transfersCreateReversal = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateReversal.ts
-var args130, tool$transfersCreateReversal;
+var args134, tool$transfersCreateReversal;
 var init_transfersCreateReversal2 = __esm(() => {
   init_transfersCreateReversal();
   init_operations();
   init_tools();
-  args130 = {
+  args134 = {
     request: CreateReversalRequest$inboundSchema
   };
   tool$transfersCreateReversal = {
@@ -78099,9 +78843,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: args130,
-    tool: async (client, args131, ctx) => {
-      const [result, apiCall] = await transfersCreateReversal(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await transfersCreateReversal(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78116,9 +78860,9 @@ to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGenerateOptions.ts
 function transfersGenerateOptions(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 = safeParse(request, (value) => CreateTransferOptionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78202,12 +78946,12 @@ var init_transfersGenerateOptions = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGenerateOptions.ts
-var args131, tool$transfersGenerateOptions;
+var args135, tool$transfersGenerateOptions;
 var init_transfersGenerateOptions2 = __esm(() => {
   init_transfersGenerateOptions();
   init_operations();
   init_tools();
-  args131 = {
+  args135 = {
     request: CreateTransferOptionsRequest$inboundSchema
   };
   tool$transfersGenerateOptions = {
@@ -78221,9 +78965,9 @@ Read our [transfers overview guide](https://docs.moov.io/guides/money-movement/o
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args131,
-    tool: async (client, args132, ctx) => {
-      const [result, apiCall] = await transfersGenerateOptions(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await transfersGenerateOptions(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78238,9 +78982,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGet.ts
 function transfersGet(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 = safeParse(request, (value) => GetTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78322,12 +79066,12 @@ var init_transfersGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGet.ts
-var args132, tool$transfersGet;
+var args136, tool$transfersGet;
 var init_transfersGet2 = __esm(() => {
   init_transfersGet();
   init_operations();
   init_tools();
-  args132 = {
+  args136 = {
     request: GetTransferRequest$inboundSchema
   };
   tool$transfersGet = {
@@ -78339,9 +79083,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: args132,
-    tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await transfersGet(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await transfersGet(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78356,9 +79100,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersGetCancellation.ts
 function transfersGetCancellation(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 = safeParse(request, (value) => GetCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78444,12 +79188,12 @@ var init_transfersGetCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetCancellation.ts
-var args133, tool$transfersGetCancellation;
+var args137, tool$transfersGetCancellation;
 var init_transfersGetCancellation2 = __esm(() => {
   init_transfersGetCancellation();
   init_operations();
   init_tools();
-  args133 = {
+  args137 = {
     request: GetCancellationRequest$inboundSchema
   };
   tool$transfersGetCancellation = {
@@ -78458,9 +79202,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: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await transfersGetCancellation(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await transfersGetCancellation(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78475,9 +79219,9 @@ var init_transfersGetCancellation2 = __esm(() => {
 
 // src/funcs/transfersGetRefund.ts
 function transfersGetRefund(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 = safeParse(request, (value) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78563,12 +79307,12 @@ var init_transfersGetRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetRefund.ts
-var args134, tool$transfersGetRefund;
+var args138, tool$transfersGetRefund;
 var init_transfersGetRefund2 = __esm(() => {
   init_transfersGetRefund();
   init_operations();
   init_tools();
-  args134 = {
+  args138 = {
     request: GetRefundRequest$inboundSchema
   };
   tool$transfersGetRefund = {
@@ -78577,9 +79321,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: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await transfersGetRefund(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args138,
+    tool: async (client, args139, ctx) => {
+      const [result, apiCall] = await transfersGetRefund(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78594,9 +79338,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersInitiateRefund.ts
 function transfersInitiateRefund(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 = safeParse(request, (value) => InitiateRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78688,12 +79432,12 @@ var init_transfersInitiateRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersInitiateRefund.ts
-var args135, tool$transfersInitiateRefund;
+var args139, tool$transfersInitiateRefund;
 var init_transfersInitiateRefund2 = __esm(() => {
   init_transfersInitiateRefund();
   init_operations();
   init_tools();
-  args135 = {
+  args139 = {
     request: InitiateRefundRequest$inboundSchema
   };
   tool$transfersInitiateRefund = {
@@ -78705,9 +79449,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: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await transfersInitiateRefund(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args139,
+    tool: async (client, args140, ctx) => {
+      const [result, apiCall] = await transfersInitiateRefund(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78722,9 +79466,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersList.ts
 function transfersList(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 = safeParse(request, (value) => ListTransfersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78820,12 +79564,12 @@ var init_transfersList = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersList.ts
-var args136, tool$transfersList;
+var args140, tool$transfersList;
 var init_transfersList2 = __esm(() => {
   init_transfersList();
   init_operations();
   init_tools();
-  args136 = {
+  args140 = {
     request: ListTransfersRequest$inboundSchema
   };
   tool$transfersList = {
@@ -78841,9 +79585,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: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await transfersList(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args140,
+    tool: async (client, args141, ctx) => {
+      const [result, apiCall] = await transfersList(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78858,9 +79602,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersListRefunds.ts
 function transfersListRefunds(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 = safeParse(request, (value) => ListRefundsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78942,12 +79686,12 @@ var init_transfersListRefunds = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersListRefunds.ts
-var args137, tool$transfersListRefunds;
+var args141, tool$transfersListRefunds;
 var init_transfersListRefunds2 = __esm(() => {
   init_transfersListRefunds();
   init_operations();
   init_tools();
-  args137 = {
+  args141 = {
     request: ListRefundsRequest$inboundSchema
   };
   tool$transfersListRefunds = {
@@ -78956,9 +79700,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: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await transfersListRefunds(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args141,
+    tool: async (client, args142, ctx) => {
+      const [result, apiCall] = await transfersListRefunds(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78973,9 +79717,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersUpdate.ts
 function transfersUpdate(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 = safeParse(request, (value) => UpdateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79061,12 +79805,12 @@ var init_transfersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersUpdate.ts
-var args138, tool$transfersUpdate;
+var args142, tool$transfersUpdate;
 var init_transfersUpdate2 = __esm(() => {
   init_transfersUpdate();
   init_operations();
   init_tools();
-  args138 = {
+  args142 = {
     request: UpdateTransferRequest$inboundSchema
   };
   tool$transfersUpdate = {
@@ -79077,9 +79821,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: args138,
-    tool: async (client, args139, ctx) => {
-      const [result, apiCall] = await transfersUpdate(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args142,
+    tool: async (client, args143, ctx) => {
+      const [result, apiCall] = await transfersUpdate(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79094,9 +79838,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/underwritingGet.ts
 function underwritingGet(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 = safeParse(request, (value) => GetUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79174,12 +79918,12 @@ var init_underwritingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingGet.ts
-var args139, tool$underwritingGet;
+var args143, tool$underwritingGet;
 var init_underwritingGet2 = __esm(() => {
   init_underwritingGet();
   init_operations();
   init_tools();
-  args139 = {
+  args143 = {
     request: GetUnderwritingRequest$inboundSchema
   };
   tool$underwritingGet = {
@@ -79190,9 +79934,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: args139,
-    tool: async (client, args140, ctx) => {
-      const [result, apiCall] = await underwritingGet(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args143,
+    tool: async (client, args144, ctx) => {
+      const [result, apiCall] = await underwritingGet(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79207,9 +79951,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/underwritingSave.ts
 function underwritingSave(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 = safeParse(request, (value) => SaveUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79305,12 +80049,12 @@ var init_underwritingSave = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingSave.ts
-var args140, tool$underwritingSave;
+var args144, tool$underwritingSave;
 var init_underwritingSave2 = __esm(() => {
   init_underwritingSave();
   init_operations();
   init_tools();
-  args140 = {
+  args144 = {
     request: SaveUnderwritingRequest$inboundSchema
   };
   tool$underwritingSave = {
@@ -79321,9 +80065,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: args140,
-    tool: async (client, args141, ctx) => {
-      const [result, apiCall] = await underwritingSave(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args144,
+    tool: async (client, args145, ctx) => {
+      const [result, apiCall] = await underwritingSave(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79338,9 +80082,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/underwritingUpsert.ts
 function underwritingUpsert(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 = safeParse(request, (value) => UpsertUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79436,12 +80180,12 @@ var init_underwritingUpsert = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingUpsert.ts
-var args141, tool$underwritingUpsert;
+var args145, tool$underwritingUpsert;
 var init_underwritingUpsert2 = __esm(() => {
   init_underwritingUpsert();
   init_operations();
   init_tools();
-  args141 = {
+  args145 = {
     request: UpsertUnderwritingRequest$inboundSchema
   };
   tool$underwritingUpsert = {
@@ -79452,9 +80196,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: args141,
-    tool: async (client, args142, ctx) => {
-      const [result, apiCall] = await underwritingUpsert(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args145,
+    tool: async (client, args146, ctx) => {
+      const [result, apiCall] = await underwritingUpsert(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79469,9 +80213,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/walletsCreate.ts
 function walletsCreate(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 = safeParse(request, (value) => CreateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79565,12 +80309,12 @@ var init_walletsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsCreate.ts
-var args142, tool$walletsCreate;
+var args146, tool$walletsCreate;
 var init_walletsCreate2 = __esm(() => {
   init_walletsCreate();
   init_operations();
   init_tools();
-  args142 = {
+  args146 = {
     request: CreateWalletRequest$inboundSchema
   };
   tool$walletsCreate = {
@@ -79581,9 +80325,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: args142,
-    tool: async (client, args143, ctx) => {
-      const [result, apiCall] = await walletsCreate(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args146,
+    tool: async (client, args147, ctx) => {
+      const [result, apiCall] = await walletsCreate(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79598,9 +80342,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletsGet.ts
 function walletsGet(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 = safeParse(request, (value) => GetWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79682,12 +80426,12 @@ var init_walletsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsGet.ts
-var args143, tool$walletsGet;
+var args147, tool$walletsGet;
 var init_walletsGet2 = __esm(() => {
   init_walletsGet();
   init_operations();
   init_tools();
-  args143 = {
+  args147 = {
     request: GetWalletRequest$inboundSchema
   };
   tool$walletsGet = {
@@ -79698,9 +80442,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: args143,
-    tool: async (client, args144, ctx) => {
-      const [result, apiCall] = await walletsGet(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args147,
+    tool: async (client, args148, ctx) => {
+      const [result, apiCall] = await walletsGet(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79715,9 +80459,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsList.ts
 function walletsList(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 = safeParse(request, (value) => ListWalletsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79805,12 +80549,12 @@ var init_walletsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsList.ts
-var args144, tool$walletsList;
+var args148, tool$walletsList;
 var init_walletsList2 = __esm(() => {
   init_walletsList();
   init_operations();
   init_tools();
-  args144 = {
+  args148 = {
     request: ListWalletsRequest$inboundSchema
   };
   tool$walletsList = {
@@ -79821,9 +80565,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: args144,
-    tool: async (client, args145, ctx) => {
-      const [result, apiCall] = await walletsList(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args148,
+    tool: async (client, args149, ctx) => {
+      const [result, apiCall] = await walletsList(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79838,9 +80582,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsUpdate.ts
 function walletsUpdate(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 = safeParse(request, (value) => UpdateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79938,12 +80682,12 @@ var init_walletsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsUpdate.ts
-var args145, tool$walletsUpdate;
+var args149, tool$walletsUpdate;
 var init_walletsUpdate2 = __esm(() => {
   init_walletsUpdate();
   init_operations();
   init_tools();
-  args145 = {
+  args149 = {
     request: UpdateWalletRequest$inboundSchema
   };
   tool$walletsUpdate = {
@@ -79954,9 +80698,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: args145,
-    tool: async (client, args146, ctx) => {
-      const [result, apiCall] = await walletsUpdate(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args149,
+    tool: async (client, args150, ctx) => {
+      const [result, apiCall] = await walletsUpdate(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79971,9 +80715,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletTransactionsGet.ts
 function walletTransactionsGet(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 = safeParse(request, (value) => GetWalletTransactionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80059,12 +80803,12 @@ var init_walletTransactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsGet.ts
-var args146, tool$walletTransactionsGet;
+var args150, tool$walletTransactionsGet;
 var init_walletTransactionsGet2 = __esm(() => {
   init_walletTransactionsGet();
   init_operations();
   init_tools();
-  args146 = {
+  args150 = {
     request: GetWalletTransactionRequest$inboundSchema
   };
   tool$walletTransactionsGet = {
@@ -80075,9 +80819,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: args146,
-    tool: async (client, args147, ctx) => {
-      const [result, apiCall] = await walletTransactionsGet(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args150,
+    tool: async (client, args151, ctx) => {
+      const [result, apiCall] = await walletTransactionsGet(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80092,9 +80836,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletTransactionsList.ts
 function walletTransactionsList(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 = safeParse(request, (value) => ListWalletTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80194,12 +80938,12 @@ var init_walletTransactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsList.ts
-var args147, tool$walletTransactionsList;
+var args151, tool$walletTransactionsList;
 var init_walletTransactionsList2 = __esm(() => {
   init_walletTransactionsList();
   init_operations();
   init_tools();
-  args147 = {
+  args151 = {
     request: ListWalletTransactionsRequest$inboundSchema
   };
   tool$walletTransactionsList = {
@@ -80210,9 +80954,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: args147,
-    tool: async (client, args148, ctx) => {
-      const [result, apiCall] = await walletTransactionsList(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args151,
+    tool: async (client, args152, ctx) => {
+      const [result, apiCall] = await walletTransactionsList(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80229,7 +80973,7 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Moov",
-    version: "0.15.5"
+    version: "0.15.7"
   });
   const client = new MoovCore({
     security: deps.security,
@@ -80303,6 +81047,10 @@ function createMCPServer(deps) {
   tool(tool$filesUpload);
   tool(tool$filesList);
   tool(tool$filesGet);
+  tool(tool$imagesList);
+  tool(tool$imagesGetMetadata);
+  tool(tool$imagesDelete);
+  tool(tool$imagesGetPublic);
   tool(tool$paymentLinksCreate);
   tool(tool$paymentLinksList);
   tool(tool$paymentLinksGet);
@@ -80473,6 +81221,10 @@ var init_server2 = __esm(() => {
   init_filesGet2();
   init_filesList2();
   init_filesUpload2();
+  init_imagesDelete2();
+  init_imagesGetMetadata2();
+  init_imagesGetPublic2();
+  init_imagesList2();
   init_industriesList2();
   init_institutionsSearch2();
   init_institutionsSearchInstitutions2();
@@ -81747,7 +82499,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.15.5"
+    currentVersion: "0.15.7"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -81755,5 +82507,5 @@ export {
   app
 };
 
-//# debugId=A41C18FB603EA31F64756E2164756E21
+//# debugId=1493228D02582F0064756E2164756E21
 //# sourceMappingURL=mcp-server.js.map