@moovio/sdk 0.16.4 → 0.16.5

package/bin/mcp-server.js

@@ -34175,9 +34175,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "latest",
-    sdkVersion: "0.16.4",
+    sdkVersion: "0.16.5",
     genVersion: "2.723.11",
-    userAgent: "speakeasy-sdk/typescript 0.16.4 2.723.11 latest @moovio/sdk"
+    userAgent: "speakeasy-sdk/typescript 0.16.5 2.723.11 latest @moovio/sdk"
   };
 });
 
@@ -37293,6 +37293,24 @@ var init_amount = __esm(() => {
   })(Amount$ ||= {});
 });
 
+// src/models/components/amountdecimalvalidationerror.ts
+var AmountDecimalValidationError$inboundSchema, AmountDecimalValidationError$outboundSchema, AmountDecimalValidationError$;
+var init_amountdecimalvalidationerror = __esm(() => {
+  init_esm();
+  AmountDecimalValidationError$inboundSchema = objectType({
+    currency: stringType().optional(),
+    valueDecimal: stringType().optional()
+  });
+  AmountDecimalValidationError$outboundSchema = objectType({
+    currency: stringType().optional(),
+    valueDecimal: stringType().optional()
+  });
+  ((AmountDecimalValidationError$) => {
+    AmountDecimalValidationError$.inboundSchema = AmountDecimalValidationError$inboundSchema;
+    AmountDecimalValidationError$.outboundSchema = AmountDecimalValidationError$outboundSchema;
+  })(AmountDecimalValidationError$ ||= {});
+});
+
 // src/models/components/amountupdate.ts
 var AmountUpdate$inboundSchema, AmountUpdate$outboundSchema, AmountUpdate$;
 var init_amountupdate = __esm(() => {
@@ -37559,6 +37577,38 @@ var init_applicationscope = __esm(() => {
   })(ApplicationScope$ ||= {});
 });
 
+// src/models/components/assignproductimage.ts
+var AssignProductImage$inboundSchema, AssignProductImage$outboundSchema, AssignProductImage$;
+var init_assignproductimage = __esm(() => {
+  init_esm();
+  AssignProductImage$inboundSchema = objectType({
+    imageID: stringType()
+  });
+  AssignProductImage$outboundSchema = objectType({
+    imageID: stringType()
+  });
+  ((AssignProductImage$) => {
+    AssignProductImage$.inboundSchema = AssignProductImage$inboundSchema;
+    AssignProductImage$.outboundSchema = AssignProductImage$outboundSchema;
+  })(AssignProductImage$ ||= {});
+});
+
+// src/models/components/assignproductimagevalidationerror.ts
+var AssignProductImageValidationError$inboundSchema, AssignProductImageValidationError$outboundSchema, AssignProductImageValidationError$;
+var init_assignproductimagevalidationerror = __esm(() => {
+  init_esm();
+  AssignProductImageValidationError$inboundSchema = objectType({
+    imageID: stringType().optional()
+  });
+  AssignProductImageValidationError$outboundSchema = objectType({
+    imageID: stringType().optional()
+  });
+  ((AssignProductImageValidationError$) => {
+    AssignProductImageValidationError$.inboundSchema = AssignProductImageValidationError$inboundSchema;
+    AssignProductImageValidationError$.outboundSchema = AssignProductImageValidationError$outboundSchema;
+  })(AssignProductImageValidationError$ ||= {});
+});
+
 // src/models/components/asynccreatedrefund.ts
 var AsyncCreatedRefund$inboundSchema, AsyncCreatedRefund$outboundSchema, AsyncCreatedRefund$;
 var init_asynccreatedrefund = __esm(() => {
@@ -43500,6 +43550,54 @@ var init_createpaymentlink = __esm(() => {
   })(CreatePaymentLink$ ||= {});
 });
 
+// src/models/components/createproductoption.ts
+var CreateProductOption$inboundSchema, CreateProductOption$outboundSchema, CreateProductOption$;
+var init_createproductoption = __esm(() => {
+  init_esm();
+  init_assignproductimage();
+  CreateProductOption$inboundSchema = objectType({
+    name: stringType(),
+    description: stringType().optional(),
+    priceModifier: stringType().optional(),
+    images: arrayType(AssignProductImage$inboundSchema).optional()
+  });
+  CreateProductOption$outboundSchema = objectType({
+    name: stringType(),
+    description: stringType().optional(),
+    priceModifier: stringType().optional(),
+    images: arrayType(AssignProductImage$outboundSchema).optional()
+  });
+  ((CreateProductOption$) => {
+    CreateProductOption$.inboundSchema = CreateProductOption$inboundSchema;
+    CreateProductOption$.outboundSchema = CreateProductOption$outboundSchema;
+  })(CreateProductOption$ ||= {});
+});
+
+// src/models/components/createproductoptiongroup.ts
+var CreateProductOptionGroup$inboundSchema, CreateProductOptionGroup$outboundSchema, CreateProductOptionGroup$;
+var init_createproductoptiongroup = __esm(() => {
+  init_esm();
+  init_createproductoption();
+  CreateProductOptionGroup$inboundSchema = objectType({
+    name: stringType(),
+    description: stringType().optional(),
+    minSelect: numberType().int(),
+    maxSelect: numberType().int(),
+    options: arrayType(CreateProductOption$inboundSchema)
+  });
+  CreateProductOptionGroup$outboundSchema = objectType({
+    name: stringType(),
+    description: stringType().optional(),
+    minSelect: numberType().int(),
+    maxSelect: numberType().int(),
+    options: arrayType(CreateProductOption$outboundSchema)
+  });
+  ((CreateProductOptionGroup$) => {
+    CreateProductOptionGroup$.inboundSchema = CreateProductOptionGroup$inboundSchema;
+    CreateProductOptionGroup$.outboundSchema = CreateProductOptionGroup$outboundSchema;
+  })(CreateProductOptionGroup$ ||= {});
+});
+
 // src/models/components/createprofileerror.ts
 var CreateProfileError$inboundSchema, CreateProfileError$outboundSchema, CreateProfileError$;
 var init_createprofileerror = __esm(() => {
@@ -47218,6 +47316,184 @@ var init_platformfees = __esm(() => {
   })(PlatformFees$ ||= {});
 });
 
+// src/models/components/productimagemetadata.ts
+var ProductImageMetadata$inboundSchema, ProductImageMetadata$outboundSchema, ProductImageMetadata$;
+var init_productimagemetadata = __esm(() => {
+  init_esm();
+  ProductImageMetadata$inboundSchema = objectType({
+    imageID: stringType(),
+    altText: stringType().optional(),
+    link: stringType()
+  });
+  ProductImageMetadata$outboundSchema = objectType({
+    imageID: stringType(),
+    altText: stringType().optional(),
+    link: stringType()
+  });
+  ((ProductImageMetadata$) => {
+    ProductImageMetadata$.inboundSchema = ProductImageMetadata$inboundSchema;
+    ProductImageMetadata$.outboundSchema = ProductImageMetadata$outboundSchema;
+  })(ProductImageMetadata$ ||= {});
+});
+
+// src/models/components/productoption.ts
+var ProductOption$inboundSchema, ProductOption$outboundSchema, ProductOption$;
+var init_productoption = __esm(() => {
+  init_esm();
+  init_productimagemetadata();
+  ProductOption$inboundSchema = objectType({
+    name: stringType(),
+    description: stringType().optional(),
+    priceModifier: stringType().optional(),
+    images: arrayType(ProductImageMetadata$inboundSchema).optional()
+  });
+  ProductOption$outboundSchema = objectType({
+    name: stringType(),
+    description: stringType().optional(),
+    priceModifier: stringType().optional(),
+    images: arrayType(ProductImageMetadata$outboundSchema).optional()
+  });
+  ((ProductOption$) => {
+    ProductOption$.inboundSchema = ProductOption$inboundSchema;
+    ProductOption$.outboundSchema = ProductOption$outboundSchema;
+  })(ProductOption$ ||= {});
+});
+
+// src/models/components/productoptiongroup.ts
+var ProductOptionGroup$inboundSchema, ProductOptionGroup$outboundSchema, ProductOptionGroup$;
+var init_productoptiongroup = __esm(() => {
+  init_esm();
+  init_productoption();
+  ProductOptionGroup$inboundSchema = objectType({
+    name: stringType(),
+    description: stringType().optional(),
+    minSelect: numberType().int(),
+    maxSelect: numberType().int(),
+    options: arrayType(ProductOption$inboundSchema)
+  });
+  ProductOptionGroup$outboundSchema = objectType({
+    name: stringType(),
+    description: stringType().optional(),
+    minSelect: numberType().int(),
+    maxSelect: numberType().int(),
+    options: arrayType(ProductOption$outboundSchema)
+  });
+  ((ProductOptionGroup$) => {
+    ProductOptionGroup$.inboundSchema = ProductOptionGroup$inboundSchema;
+    ProductOptionGroup$.outboundSchema = ProductOptionGroup$outboundSchema;
+  })(ProductOptionGroup$ ||= {});
+});
+
+// src/models/components/product.ts
+var Product$inboundSchema, Product$outboundSchema, Product$;
+var init_product = __esm(() => {
+  init_esm();
+  init_amountdecimal();
+  init_productimagemetadata();
+  init_productoptiongroup();
+  Product$inboundSchema = objectType({
+    productID: stringType(),
+    title: stringType(),
+    description: stringType().optional(),
+    basePrice: AmountDecimal$inboundSchema,
+    optionGroups: arrayType(ProductOptionGroup$inboundSchema).optional(),
+    images: arrayType(ProductImageMetadata$inboundSchema).optional(),
+    createdOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    updatedOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    disabledOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional()
+  });
+  Product$outboundSchema = objectType({
+    productID: stringType(),
+    title: stringType(),
+    description: stringType().optional(),
+    basePrice: AmountDecimal$outboundSchema,
+    optionGroups: arrayType(ProductOptionGroup$outboundSchema).optional(),
+    images: arrayType(ProductImageMetadata$outboundSchema).optional(),
+    createdOn: dateType().transform((v2) => v2.toISOString()),
+    updatedOn: dateType().transform((v2) => v2.toISOString()),
+    disabledOn: dateType().transform((v2) => v2.toISOString()).optional()
+  });
+  ((Product$) => {
+    Product$.inboundSchema = Product$inboundSchema;
+    Product$.outboundSchema = Product$outboundSchema;
+  })(Product$ ||= {});
+});
+
+// src/models/components/productoptionvalidationerror.ts
+var ProductOptionValidationError$inboundSchema, ProductOptionValidationError$outboundSchema, ProductOptionValidationError$;
+var init_productoptionvalidationerror = __esm(() => {
+  init_esm();
+  init_assignproductimagevalidationerror();
+  ProductOptionValidationError$inboundSchema = objectType({
+    name: stringType().optional(),
+    description: stringType().optional(),
+    priceModifier: stringType().optional(),
+    images: recordType(AssignProductImageValidationError$inboundSchema).optional()
+  });
+  ProductOptionValidationError$outboundSchema = objectType({
+    name: stringType().optional(),
+    description: stringType().optional(),
+    priceModifier: stringType().optional(),
+    images: recordType(AssignProductImageValidationError$outboundSchema).optional()
+  });
+  ((ProductOptionValidationError$) => {
+    ProductOptionValidationError$.inboundSchema = ProductOptionValidationError$inboundSchema;
+    ProductOptionValidationError$.outboundSchema = ProductOptionValidationError$outboundSchema;
+  })(ProductOptionValidationError$ ||= {});
+});
+
+// src/models/components/productoptiongroupvalidationerror.ts
+var ProductOptionGroupValidationError$inboundSchema, ProductOptionGroupValidationError$outboundSchema, ProductOptionGroupValidationError$;
+var init_productoptiongroupvalidationerror = __esm(() => {
+  init_esm();
+  init_productoptionvalidationerror();
+  ProductOptionGroupValidationError$inboundSchema = objectType({
+    name: stringType().optional(),
+    description: stringType().optional(),
+    minSelect: stringType().optional(),
+    maxSelect: stringType().optional(),
+    options: recordType(ProductOptionValidationError$inboundSchema).optional()
+  });
+  ProductOptionGroupValidationError$outboundSchema = objectType({
+    name: stringType().optional(),
+    description: stringType().optional(),
+    minSelect: stringType().optional(),
+    maxSelect: stringType().optional(),
+    options: recordType(ProductOptionValidationError$outboundSchema).optional()
+  });
+  ((ProductOptionGroupValidationError$) => {
+    ProductOptionGroupValidationError$.inboundSchema = ProductOptionGroupValidationError$inboundSchema;
+    ProductOptionGroupValidationError$.outboundSchema = ProductOptionGroupValidationError$outboundSchema;
+  })(ProductOptionGroupValidationError$ ||= {});
+});
+
+// src/models/components/productrequest.ts
+var ProductRequest$inboundSchema, ProductRequest$outboundSchema, ProductRequest$;
+var init_productrequest = __esm(() => {
+  init_esm();
+  init_amountdecimal();
+  init_assignproductimage();
+  init_createproductoptiongroup();
+  ProductRequest$inboundSchema = objectType({
+    title: stringType(),
+    description: stringType().optional(),
+    basePrice: AmountDecimal$inboundSchema,
+    images: arrayType(AssignProductImage$inboundSchema).optional(),
+    optionGroups: arrayType(CreateProductOptionGroup$inboundSchema).optional()
+  });
+  ProductRequest$outboundSchema = objectType({
+    title: stringType(),
+    description: stringType().optional(),
+    basePrice: AmountDecimal$outboundSchema,
+    images: arrayType(AssignProductImage$outboundSchema).optional(),
+    optionGroups: arrayType(CreateProductOptionGroup$outboundSchema).optional()
+  });
+  ((ProductRequest$) => {
+    ProductRequest$.inboundSchema = ProductRequest$inboundSchema;
+    ProductRequest$.outboundSchema = ProductRequest$outboundSchema;
+  })(ProductRequest$ ||= {});
+});
+
 // src/models/components/qrcode.ts
 var QRCode$inboundSchema, QRCode$outboundSchema, QRCode$;
 var init_qrcode = __esm(() => {
@@ -50171,6 +50447,7 @@ var init_components = __esm(() => {
   init_adjustment();
   init_amount();
   init_amountdecimal();
+  init_amountdecimalvalidationerror();
   init_amountupdate();
   init_amountvalidationerror();
   init_applebillingcontact();
@@ -50179,6 +50456,8 @@ var init_components = __esm(() => {
   init_applepaypaymentmethod();
   init_applepayresponse();
   init_applicationscope();
+  init_assignproductimage();
+  init_assignproductimagevalidationerror();
   init_asynccreatedrefund();
   init_asynctransfer();
   init_authorizeduser();
@@ -50278,6 +50557,8 @@ var init_components = __esm(() => {
   init_createindividualerror();
   init_createindividualprofile();
   init_createpaymentlink();
+  init_createproductoption();
+  init_createproductoptiongroup();
   init_createprofile();
   init_createprofileerror();
   init_createrefund();
@@ -50456,6 +50737,13 @@ var init_components = __esm(() => {
   init_plaidpayload();
   init_platformfees();
   init_primaryregulator();
+  init_product();
+  init_productimagemetadata();
+  init_productoption();
+  init_productoptiongroup();
+  init_productoptiongroupvalidationerror();
+  init_productoptionvalidationerror();
+  init_productrequest();
   init_profile();
   init_pullfromcardpaymentmethod();
   init_pushtocardpaymentmethod();
@@ -51940,6 +52228,65 @@ var init_patchwalletvalidationerror = __esm(() => {
   })(PatchWalletValidationError$ ||= {});
 });
 
+// src/models/errors/productrequestvalidationerror.ts
+var ProductRequestValidationError, ProductRequestValidationError$inboundSchema, ProductRequestValidationError$outboundSchema, ProductRequestValidationError$;
+var init_productrequestvalidationerror = __esm(() => {
+  init_esm();
+  init_components();
+  init_mooverror();
+  ProductRequestValidationError = class ProductRequestValidationError extends MoovError {
+    title;
+    description;
+    basePrice;
+    images;
+    optionGroups;
+    data$;
+    constructor(err, httpMeta) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message, httpMeta);
+      this.data$ = err;
+      if (err.title != null)
+        this.title = err.title;
+      if (err.description != null)
+        this.description = err.description;
+      if (err.basePrice != null)
+        this.basePrice = err.basePrice;
+      if (err.images != null)
+        this.images = err.images;
+      if (err.optionGroups != null)
+        this.optionGroups = err.optionGroups;
+      this.name = "ProductRequestValidationError";
+    }
+  };
+  ProductRequestValidationError$inboundSchema = objectType({
+    title: stringType().optional(),
+    description: stringType().optional(),
+    basePrice: AmountDecimalValidationError$inboundSchema.optional(),
+    images: recordType(AssignProductImageValidationError$inboundSchema).optional(),
+    optionGroups: recordType(ProductOptionGroupValidationError$inboundSchema).optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new ProductRequestValidationError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  ProductRequestValidationError$outboundSchema = instanceOfType(ProductRequestValidationError).transform((v2) => v2.data$).pipe(objectType({
+    title: stringType().optional(),
+    description: stringType().optional(),
+    basePrice: AmountDecimalValidationError$outboundSchema.optional(),
+    images: recordType(AssignProductImageValidationError$outboundSchema).optional(),
+    optionGroups: recordType(ProductOptionGroupValidationError$outboundSchema).optional()
+  }));
+  ((ProductRequestValidationError$) => {
+    ProductRequestValidationError$.inboundSchema = ProductRequestValidationError$inboundSchema;
+    ProductRequestValidationError$.outboundSchema = ProductRequestValidationError$outboundSchema;
+  })(ProductRequestValidationError$ ||= {});
+});
+
 // src/models/errors/refundvalidationerror.ts
 var RefundValidationError, RefundValidationError$inboundSchema, RefundValidationError$outboundSchema, RefundValidationError$;
 var init_refundvalidationerror = __esm(() => {
@@ -53033,6 +53380,7 @@ var init_errors2 = __esm(() => {
   init_patchsweepconfigerror();
   init_patchtransfervalidationerror();
   init_patchwalletvalidationerror();
+  init_productrequestvalidationerror();
   init_refundvalidationerror();
   init_representativevalidationerror();
   init_requestcarderror();
@@ -53852,6 +54200,74 @@ var init_createpaymentlink2 = __esm(() => {
   })(CreatePaymentLinkResponse$ ||= {});
 });
 
+// src/models/operations/createproduct.ts
+var CreateProductGlobals$inboundSchema, CreateProductGlobals$outboundSchema, CreateProductGlobals$, CreateProductRequest$inboundSchema, CreateProductRequest$outboundSchema, CreateProductRequest$, CreateProductResponse$inboundSchema, CreateProductResponse$outboundSchema, CreateProductResponse$;
+var init_createproduct = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  CreateProductGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  CreateProductGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((CreateProductGlobals$) => {
+    CreateProductGlobals$.inboundSchema = CreateProductGlobals$inboundSchema;
+    CreateProductGlobals$.outboundSchema = CreateProductGlobals$outboundSchema;
+  })(CreateProductGlobals$ ||= {});
+  CreateProductRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    ProductRequest: ProductRequest$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      ProductRequest: "productRequest"
+    });
+  });
+  CreateProductRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    productRequest: ProductRequest$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      productRequest: "ProductRequest"
+    });
+  });
+  ((CreateProductRequest$) => {
+    CreateProductRequest$.inboundSchema = CreateProductRequest$inboundSchema;
+    CreateProductRequest$.outboundSchema = CreateProductRequest$outboundSchema;
+  })(CreateProductRequest$ ||= {});
+  CreateProductResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: Product$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  CreateProductResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Product$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((CreateProductResponse$) => {
+    CreateProductResponse$.inboundSchema = CreateProductResponse$inboundSchema;
+    CreateProductResponse$.outboundSchema = CreateProductResponse$outboundSchema;
+  })(CreateProductResponse$ ||= {});
+});
+
 // src/models/operations/createreceipts.ts
 var CreateReceiptsGlobals$inboundSchema, CreateReceiptsGlobals$outboundSchema, CreateReceiptsGlobals$, CreateReceiptsResponse$inboundSchema, CreateReceiptsResponse$outboundSchema, CreateReceiptsResponse$;
 var init_createreceipts = __esm(() => {
@@ -55037,6 +55453,61 @@ var init_disablepaymentlink = __esm(() => {
   })(DisablePaymentLinkResponse$ ||= {});
 });
 
+// src/models/operations/disableproduct.ts
+var DisableProductGlobals$inboundSchema, DisableProductGlobals$outboundSchema, DisableProductGlobals$, DisableProductRequest$inboundSchema, DisableProductRequest$outboundSchema, DisableProductRequest$, DisableProductResponse$inboundSchema, DisableProductResponse$outboundSchema, DisableProductResponse$;
+var init_disableproduct = __esm(() => {
+  init_esm();
+  init_primitives();
+  DisableProductGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  DisableProductGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((DisableProductGlobals$) => {
+    DisableProductGlobals$.inboundSchema = DisableProductGlobals$inboundSchema;
+    DisableProductGlobals$.outboundSchema = DisableProductGlobals$outboundSchema;
+  })(DisableProductGlobals$ ||= {});
+  DisableProductRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    productID: stringType()
+  });
+  DisableProductRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    productID: stringType()
+  });
+  ((DisableProductRequest$) => {
+    DisableProductRequest$.inboundSchema = DisableProductRequest$inboundSchema;
+    DisableProductRequest$.outboundSchema = DisableProductRequest$outboundSchema;
+  })(DisableProductRequest$ ||= {});
+  DisableProductResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType()))
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers"
+    });
+  });
+  DisableProductResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType()))
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers"
+    });
+  });
+  ((DisableProductResponse$) => {
+    DisableProductResponse$.inboundSchema = DisableProductResponse$inboundSchema;
+    DisableProductResponse$.outboundSchema = DisableProductResponse$outboundSchema;
+  })(DisableProductResponse$ ||= {});
+});
+
 // src/models/operations/disconnectaccount.ts
 var DisconnectAccountGlobals$inboundSchema, DisconnectAccountGlobals$outboundSchema, DisconnectAccountGlobals$, DisconnectAccountRequest$inboundSchema, DisconnectAccountRequest$outboundSchema, DisconnectAccountRequest$, DisconnectAccountResponse$inboundSchema, DisconnectAccountResponse$outboundSchema, DisconnectAccountResponse$;
 var init_disconnectaccount = __esm(() => {
@@ -56873,6 +57344,66 @@ var init_getpaymentmethod = __esm(() => {
   })(GetPaymentMethodResponse$ ||= {});
 });
 
+// src/models/operations/getproduct.ts
+var GetProductGlobals$inboundSchema, GetProductGlobals$outboundSchema, GetProductGlobals$, GetProductRequest$inboundSchema, GetProductRequest$outboundSchema, GetProductRequest$, GetProductResponse$inboundSchema, GetProductResponse$outboundSchema, GetProductResponse$;
+var init_getproduct = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  GetProductGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  GetProductGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((GetProductGlobals$) => {
+    GetProductGlobals$.inboundSchema = GetProductGlobals$inboundSchema;
+    GetProductGlobals$.outboundSchema = GetProductGlobals$outboundSchema;
+  })(GetProductGlobals$ ||= {});
+  GetProductRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    productID: stringType()
+  });
+  GetProductRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    productID: stringType()
+  });
+  ((GetProductRequest$) => {
+    GetProductRequest$.inboundSchema = GetProductRequest$inboundSchema;
+    GetProductRequest$.outboundSchema = GetProductRequest$outboundSchema;
+  })(GetProductRequest$ ||= {});
+  GetProductResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: Product$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  GetProductResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Product$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((GetProductResponse$) => {
+    GetProductResponse$.inboundSchema = GetProductResponse$inboundSchema;
+    GetProductResponse$.outboundSchema = GetProductResponse$outboundSchema;
+  })(GetProductResponse$ ||= {});
+});
+
 // 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(() => {
@@ -59871,6 +60402,68 @@ var init_listpaymentmethods = __esm(() => {
   })(ListPaymentMethodsResponse$ ||= {});
 });
 
+// src/models/operations/listproducts.ts
+var ListProductsGlobals$inboundSchema, ListProductsGlobals$outboundSchema, ListProductsGlobals$, ListProductsRequest$inboundSchema, ListProductsRequest$outboundSchema, ListProductsRequest$, ListProductsResponse$inboundSchema, ListProductsResponse$outboundSchema, ListProductsResponse$;
+var init_listproducts = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ListProductsGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  ListProductsGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((ListProductsGlobals$) => {
+    ListProductsGlobals$.inboundSchema = ListProductsGlobals$inboundSchema;
+    ListProductsGlobals$.outboundSchema = ListProductsGlobals$outboundSchema;
+  })(ListProductsGlobals$ ||= {});
+  ListProductsRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    skip: numberType().int().optional(),
+    count: numberType().int().optional()
+  });
+  ListProductsRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    skip: numberType().int().optional(),
+    count: numberType().int().optional()
+  });
+  ((ListProductsRequest$) => {
+    ListProductsRequest$.inboundSchema = ListProductsRequest$inboundSchema;
+    ListProductsRequest$.outboundSchema = ListProductsRequest$outboundSchema;
+  })(ListProductsRequest$ ||= {});
+  ListProductsResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: arrayType(Product$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ListProductsResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: arrayType(Product$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((ListProductsResponse$) => {
+    ListProductsResponse$.inboundSchema = ListProductsResponse$inboundSchema;
+    ListProductsResponse$.outboundSchema = ListProductsResponse$outboundSchema;
+  })(ListProductsResponse$ ||= {});
+});
+
 // src/models/operations/listreceipts.ts
 var ListReceiptsGlobals$inboundSchema, ListReceiptsGlobals$outboundSchema, ListReceiptsGlobals$, ListReceiptsRequest$inboundSchema, ListReceiptsRequest$outboundSchema, ListReceiptsRequest$, ListReceiptsResponse$inboundSchema, ListReceiptsResponse$outboundSchema, ListReceiptsResponse$;
 var init_listreceipts = __esm(() => {
@@ -61866,6 +62459,76 @@ var init_updatepaymentlink2 = __esm(() => {
   })(UpdatePaymentLinkResponse$ ||= {});
 });
 
+// src/models/operations/updateproduct.ts
+var UpdateProductGlobals$inboundSchema, UpdateProductGlobals$outboundSchema, UpdateProductGlobals$, UpdateProductRequest$inboundSchema, UpdateProductRequest$outboundSchema, UpdateProductRequest$, UpdateProductResponse$inboundSchema, UpdateProductResponse$outboundSchema, UpdateProductResponse$;
+var init_updateproduct = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  UpdateProductGlobals$inboundSchema = objectType({
+    "x-moov-version": stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      "x-moov-version": "xMoovVersion"
+    });
+  });
+  UpdateProductGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().default("v2024.01.00")
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "x-moov-version"
+    });
+  });
+  ((UpdateProductGlobals$) => {
+    UpdateProductGlobals$.inboundSchema = UpdateProductGlobals$inboundSchema;
+    UpdateProductGlobals$.outboundSchema = UpdateProductGlobals$outboundSchema;
+  })(UpdateProductGlobals$ ||= {});
+  UpdateProductRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    productID: stringType(),
+    ProductRequest: ProductRequest$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      ProductRequest: "productRequest"
+    });
+  });
+  UpdateProductRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    productID: stringType(),
+    productRequest: ProductRequest$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      productRequest: "ProductRequest"
+    });
+  });
+  ((UpdateProductRequest$) => {
+    UpdateProductRequest$.inboundSchema = UpdateProductRequest$inboundSchema;
+    UpdateProductRequest$.outboundSchema = UpdateProductRequest$outboundSchema;
+  })(UpdateProductRequest$ ||= {});
+  UpdateProductResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())),
+    Result: Product$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  UpdateProductResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Product$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+  ((UpdateProductResponse$) => {
+    UpdateProductResponse$.inboundSchema = UpdateProductResponse$inboundSchema;
+    UpdateProductResponse$.outboundSchema = UpdateProductResponse$outboundSchema;
+  })(UpdateProductResponse$ ||= {});
+});
+
 // src/models/operations/updaterepresentative.ts
 var UpdateRepresentativeGlobals$inboundSchema, UpdateRepresentativeGlobals$outboundSchema, UpdateRepresentativeGlobals$, UpdateRepresentativeRequest$inboundSchema, UpdateRepresentativeRequest$outboundSchema, UpdateRepresentativeRequest$, UpdateRepresentativeResponse$inboundSchema, UpdateRepresentativeResponse$outboundSchema, UpdateRepresentativeResponse$;
 var init_updaterepresentative2 = __esm(() => {
@@ -62645,6 +63308,7 @@ var init_operations = __esm(() => {
   init_createfeeplanagreements();
   init_createonboardinginvite();
   init_createpaymentlink2();
+  init_createproduct();
   init_createreceipts();
   init_createrepresentative2();
   init_createreversal2();
@@ -62664,6 +63328,7 @@ var init_operations = __esm(() => {
   init_disablecapability();
   init_disablecard();
   init_disablepaymentlink();
+  init_disableproduct();
   init_disconnectaccount();
   init_generateendtoendkey();
   init_getaccount();
@@ -62694,6 +63359,7 @@ var init_operations = __esm(() => {
   init_getpaymentlink();
   init_getpaymentlinkqrcode();
   init_getpaymentmethod();
+  init_getproduct();
   init_getpublicimage();
   init_getrefund();
   init_getrepresentative();
@@ -62741,6 +63407,7 @@ var init_operations = __esm(() => {
   init_listpartnerpricingagreements();
   init_listpaymentlinks();
   init_listpaymentmethods();
+  init_listproducts();
   init_listreceipts();
   init_listrefunds();
   init_listrepresentatives();
@@ -62772,6 +63439,7 @@ var init_operations = __esm(() => {
   init_updatedisputeevidence();
   init_updateissuedcard2();
   init_updatepaymentlink2();
+  init_updateproduct();
   init_updaterepresentative2();
   init_updateschedule();
   init_updatesweepconfig();
@@ -74827,257 +75495,24 @@ you'll need to specify the \`/ping.read\` scope.`,
   };
 });
 
-// src/funcs/receiptsCreate.ts
-function receiptsCreate(client, request, options) {
+// src/funcs/productsCreate.ts
+function productsCreate(client, request, options) {
   return new APIPromise($do101(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" }];
-  }
-  const payload = parsed.value;
-  const body = encodeJSON("body", payload, { explode: true });
-  const path = pathToFunc("/receipts")();
-  const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
-    Accept: "application/json",
-    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
-  }));
-  const securityInput = await extractSecurity(client._options.security);
-  const requestSecurity = resolveGlobalSecurity(securityInput);
-  const context = {
-    options: client._options,
-    baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "createReceipts",
-    oAuth2Scopes: null,
-    resolvedSecurity: requestSecurity,
-    securitySource: client._options.security,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
-  };
-  const requestRes = client._createRequest(context, {
-    security: requestSecurity,
-    method: "POST",
-    baseURL: options?.serverURL,
-    path,
-    headers,
-    body,
-    userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
-  }, options);
-  if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
-  }
-  const req = requestRes.value;
-  const doResult = await client._do(req, {
-    context,
-    errorCodes: [
-      "400",
-      "401",
-      "403",
-      "404",
-      "409",
-      "422",
-      "429",
-      "4XX",
-      "500",
-      "504",
-      "5XX"
-    ],
-    retryConfig: context.retryConfig,
-    retryCodes: context.retryCodes
-  });
-  if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
-  }
-  const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(201, CreateReceiptsResponse$inboundSchema, {
-    hdrs: true,
-    key: "Result"
-  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 422, 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_receiptsCreate = __esm(() => {
-  init_esm();
-  init_encodings();
-  init_matchers();
-  init_primitives();
-  init_schemas();
-  init_security();
-  init_url();
-  init_components();
-  init_errors2();
-  init_operations();
-  init_async();
-});
-
-// src/mcp-server/tools/receiptsCreate.ts
-var args101, tool$receiptsCreate;
-var init_receiptsCreate2 = __esm(() => {
-  init_esm();
-  init_receiptsCreate();
-  init_components();
-  init_tools();
-  args101 = {
-    request: arrayType(ReceiptRequest$inboundSchema)
-  };
-  tool$receiptsCreate = {
-    name: "receipts-create",
-    description: ` Create receipts for transfers and scheduled transfers.
-
- 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: 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 }],
-          isError: true
-        };
-      }
-      const value = result.value.result;
-      return formatResult(value, apiCall);
-    }
-  };
-});
-
-// src/funcs/receiptsList.ts
-function receiptsList(client, request, options) {
-  return new APIPromise($do102(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" }];
-  }
-  const payload = parsed.value;
-  const body = null;
-  const path = pathToFunc("/receipts")();
-  const query = encodeFormQuery({
-    id: payload.id
-  }, { explode: false });
-  const headers = new Headers(compactMap({
-    Accept: "application/json",
-    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
-  }));
-  const securityInput = await extractSecurity(client._options.security);
-  const requestSecurity = resolveGlobalSecurity(securityInput);
-  const context = {
-    options: client._options,
-    baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "listReceipts",
-    oAuth2Scopes: null,
-    resolvedSecurity: requestSecurity,
-    securitySource: client._options.security,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
-  };
-  const requestRes = client._createRequest(context, {
-    security: requestSecurity,
-    method: "GET",
-    baseURL: options?.serverURL,
-    path,
-    headers,
-    query,
-    body,
-    userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
-  }, options);
-  if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
-  }
-  const req = requestRes.value;
-  const doResult = await client._do(req, {
-    context,
-    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
-    retryConfig: context.retryConfig,
-    retryCodes: context.retryCodes
-  });
-  if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
-  }
-  const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(200, ListReceiptsResponse$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_receiptsList = __esm(() => {
-  init_encodings();
-  init_matchers();
-  init_primitives();
-  init_schemas();
-  init_security();
-  init_url();
-  init_operations();
-  init_async();
-});
-
-// src/mcp-server/tools/receiptsList.ts
-var args102, tool$receiptsList;
-var init_receiptsList2 = __esm(() => {
-  init_receiptsList();
-  init_operations();
-  init_tools();
-  args102 = {
-    request: ListReceiptsRequest$inboundSchema
-  };
-  tool$receiptsList = {
-    name: "receipts-list",
-    description: `List receipts by transferID, scheduleID, or occurrenceID.
-
-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: 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 }],
-          isError: true
-        };
-      }
-      const value = result.value.result;
-      return formatResult(value, apiCall);
-    }
-  };
-});
-
-// src/funcs/representativesCreate.ts
-function representativesCreate(client, request, options) {
-  return new APIPromise($do103(client, request, options));
-}
-async function $do103(client, request, options) {
-  const parsed = safeParse(request, (value) => CreateRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => CreateProductRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.CreateRepresentative, {
-    explode: true
-  });
+  const body = encodeJSON("body", payload.ProductRequest, { explode: true });
   const pathParams = {
     accountID: encodeSimple("accountID", payload.accountID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/representatives")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/products")(pathParams);
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/json",
@@ -75088,7 +75523,841 @@ async function $do103(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "createRepresentative",
+    operationID: "createProduct",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, CreateProductResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, ProductRequestValidationError$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_productsCreate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/productsCreate.ts
+var args101, tool$productsCreate;
+var init_productsCreate2 = __esm(() => {
+  init_productsCreate();
+  init_operations();
+  init_tools();
+  args101 = {
+    request: CreateProductRequest$inboundSchema
+  };
+  tool$productsCreate = {
+    name: "products-create",
+    description: `Creates a new product for the specified account.`,
+    args: args101,
+    tool: async (client, args102, ctx) => {
+      const [result, apiCall] = await productsCreate(client, args102.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/productsDisable.ts
+function productsDisable(client, request, options) {
+  return new APIPromise($do102(client, request, options));
+}
+async function $do102(client, request, options) {
+  const parsed = safeParse(request, (value) => DisableProductRequest$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"
+    }),
+    productID: encodeSimple("productID", payload.productID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/products/{productID}")(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: "disableProduct",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "DELETE",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(nil(204, DisableProductResponse$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_productsDisable = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/productsDisable.ts
+var args102, tool$productsDisable;
+var init_productsDisable2 = __esm(() => {
+  init_productsDisable();
+  init_operations();
+  init_tools();
+  args102 = {
+    request: DisableProductRequest$inboundSchema
+  };
+  tool$productsDisable = {
+    name: "products-disable",
+    description: `Disable a product by ID.
+
+The product will no longer be available, but will remain in the system for historical and reporting purposes.`,
+    args: args102,
+    tool: async (client, args103, ctx) => {
+      const [result, apiCall] = await productsDisable(client, args103.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/productsGet.ts
+function productsGet(client, request, options) {
+  return new APIPromise($do103(client, request, options));
+}
+async function $do103(client, request, options) {
+  const parsed = safeParse(request, (value) => GetProductRequest$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"
+    }),
+    productID: encodeSimple("productID", payload.productID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/products/{productID}")(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: "getProduct",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "404", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, GetProductResponse$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_productsGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/productsGet.ts
+var args103, tool$productsGet;
+var init_productsGet2 = __esm(() => {
+  init_productsGet();
+  init_operations();
+  init_tools();
+  args103 = {
+    request: GetProductRequest$inboundSchema
+  };
+  tool$productsGet = {
+    name: "products-get",
+    description: `Retrieve a product by ID.`,
+    args: args103,
+    tool: async (client, args104, ctx) => {
+      const [result, apiCall] = await productsGet(client, args104.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/productsList.ts
+function productsList(client, request, options) {
+  return new APIPromise($do104(client, request, options));
+}
+async function $do104(client, request, options) {
+  const parsed = safeParse(request, (value) => ListProductsRequest$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}/products")(pathParams);
+  const query = encodeFormQuery({
+    count: payload.count,
+    skip: payload.skip
+  }, { explode: false });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listProducts",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, ListProductsResponse$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_productsList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/productsList.ts
+var args104, tool$productsList;
+var init_productsList2 = __esm(() => {
+  init_productsList();
+  init_operations();
+  init_tools();
+  args104 = {
+    request: ListProductsRequest$inboundSchema
+  };
+  tool$productsList = {
+    name: "products-list",
+    description: `List active (non-disabled) products for an account.`,
+    args: args104,
+    tool: async (client, args105, ctx) => {
+      const [result, apiCall] = await productsList(client, args105.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/productsUpdate.ts
+function productsUpdate(client, request, options) {
+  return new APIPromise($do105(client, request, options));
+}
+async function $do105(client, request, options) {
+  const parsed = safeParse(request, (value) => UpdateProductRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.ProductRequest, { explode: true });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    productID: encodeSimple("productID", payload.productID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/products/{productID}")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "updateProduct",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "PUT",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, UpdateProductResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, ProductRequestValidationError$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_productsUpdate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/productsUpdate.ts
+var args105, tool$productsUpdate;
+var init_productsUpdate2 = __esm(() => {
+  init_productsUpdate();
+  init_operations();
+  init_tools();
+  args105 = {
+    request: UpdateProductRequest$inboundSchema
+  };
+  tool$productsUpdate = {
+    name: "products-update",
+    description: `Update a product and its options.`,
+    args: args105,
+    tool: async (client, args106, ctx) => {
+      const [result, apiCall] = await productsUpdate(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/receiptsCreate.ts
+function receiptsCreate(client, request, options) {
+  return new APIPromise($do106(client, request, options));
+}
+async function $do106(client, request, options) {
+  const parsed = safeParse(request, (value) => arrayType(ReceiptRequest$outboundSchema).parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/receipts")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "createReceipts",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, CreateReceiptsResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 422, 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_receiptsCreate = __esm(() => {
+  init_esm();
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/receiptsCreate.ts
+var args106, tool$receiptsCreate;
+var init_receiptsCreate2 = __esm(() => {
+  init_esm();
+  init_receiptsCreate();
+  init_components();
+  init_tools();
+  args106 = {
+    request: arrayType(ReceiptRequest$inboundSchema)
+  };
+  tool$receiptsCreate = {
+    name: "receipts-create",
+    description: ` Create receipts for transfers and scheduled transfers.
+
+ 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: args106,
+    tool: async (client, args107, ctx) => {
+      const [result, apiCall] = await receiptsCreate(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/receiptsList.ts
+function receiptsList(client, request, options) {
+  return new APIPromise($do107(client, request, options));
+}
+async function $do107(client, request, options) {
+  const parsed = safeParse(request, (value) => ListReceiptsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/receipts")();
+  const query = encodeFormQuery({
+    id: payload.id
+  }, { explode: false });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "listReceipts",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, ListReceiptsResponse$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_receiptsList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/receiptsList.ts
+var args107, tool$receiptsList;
+var init_receiptsList2 = __esm(() => {
+  init_receiptsList();
+  init_operations();
+  init_tools();
+  args107 = {
+    request: ListReceiptsRequest$inboundSchema
+  };
+  tool$receiptsList = {
+    name: "receipts-list",
+    description: `List receipts by transferID, scheduleID, or occurrenceID.
+
+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 receiptsList(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/representativesCreate.ts
+function representativesCreate(client, request, options) {
+  return new APIPromise($do108(client, request, options));
+}
+async function $do108(client, request, options) {
+  const parsed = safeParse(request, (value) => CreateRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.CreateRepresentative, {
+    explode: true
+  });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/representatives")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-moov-version": encodeSimple("x-moov-version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
+  }));
+  const securityInput = await extractSecurity(client._options.security);
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "createRepresentative",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -75158,12 +76427,12 @@ var init_representativesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesCreate.ts
-var args103, tool$representativesCreate;
+var args108, tool$representativesCreate;
 var init_representativesCreate2 = __esm(() => {
   init_representativesCreate();
   init_operations();
   init_tools();
-  args103 = {
+  args108 = {
     request: CreateRepresentativeRequest$inboundSchema
   };
   tool$representativesCreate = {
@@ -75174,9 +76443,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: args103,
-    tool: async (client, args104, ctx) => {
-      const [result, apiCall] = await representativesCreate(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args108,
+    tool: async (client, args109, ctx) => {
+      const [result, apiCall] = await representativesCreate(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75191,9 +76460,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/representativesDelete.ts
 function representativesDelete(client, request, options) {
-  return new APIPromise($do104(client, request, options));
+  return new APIPromise($do109(client, request, options));
 }
-async function $do104(client, request, options) {
+async function $do109(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75281,12 +76550,12 @@ var init_representativesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesDelete.ts
-var args104, tool$representativesDelete;
+var args109, tool$representativesDelete;
 var init_representativesDelete2 = __esm(() => {
   init_representativesDelete();
   init_operations();
   init_tools();
-  args104 = {
+  args109 = {
     request: DeleteRepresentativeRequest$inboundSchema
   };
   tool$representativesDelete = {
@@ -75295,9 +76564,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: args104,
-    tool: async (client, args105, ctx) => {
-      const [result, apiCall] = await representativesDelete(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args109,
+    tool: async (client, args110, ctx) => {
+      const [result, apiCall] = await representativesDelete(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75311,9 +76580,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/representativesGet.ts
 function representativesGet(client, request, options) {
-  return new APIPromise($do105(client, request, options));
+  return new APIPromise($do110(client, request, options));
 }
-async function $do105(client, request, options) {
+async function $do110(client, request, options) {
   const parsed = safeParse(request, (value) => GetRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75392,12 +76661,12 @@ var init_representativesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesGet.ts
-var args105, tool$representativesGet;
+var args110, tool$representativesGet;
 var init_representativesGet2 = __esm(() => {
   init_representativesGet();
   init_operations();
   init_tools();
-  args105 = {
+  args110 = {
     request: GetRepresentativeRequest$inboundSchema
   };
   tool$representativesGet = {
@@ -75406,9 +76675,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: args105,
-    tool: async (client, args106, ctx) => {
-      const [result, apiCall] = await representativesGet(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args110,
+    tool: async (client, args111, ctx) => {
+      const [result, apiCall] = await representativesGet(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75423,9 +76692,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.read\` scope.
 
 // src/funcs/representativesList.ts
 function representativesList(client, request, options) {
-  return new APIPromise($do106(client, request, options));
+  return new APIPromise($do111(client, request, options));
 }
-async function $do106(client, request, options) {
+async function $do111(client, request, options) {
   const parsed = safeParse(request, (value) => ListRepresentativesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75503,12 +76772,12 @@ var init_representativesList = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesList.ts
-var args106, tool$representativesList;
+var args111, tool$representativesList;
 var init_representativesList2 = __esm(() => {
   init_representativesList();
   init_operations();
   init_tools();
-  args106 = {
+  args111 = {
     request: ListRepresentativesRequest$inboundSchema
   };
   tool$representativesList = {
@@ -75520,9 +76789,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: args106,
-    tool: async (client, args107, ctx) => {
-      const [result, apiCall] = await representativesList(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args111,
+    tool: async (client, args112, ctx) => {
+      const [result, apiCall] = await representativesList(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75537,9 +76806,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.read\` scope.
 
 // src/funcs/representativesUpdate.ts
 function representativesUpdate(client, request, options) {
-  return new APIPromise($do107(client, request, options));
+  return new APIPromise($do112(client, request, options));
 }
-async function $do107(client, request, options) {
+async function $do112(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75633,12 +76902,12 @@ var init_representativesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesUpdate.ts
-var args107, tool$representativesUpdate;
+var args112, tool$representativesUpdate;
 var init_representativesUpdate2 = __esm(() => {
   init_representativesUpdate();
   init_operations();
   init_tools();
-  args107 = {
+  args112 = {
     request: UpdateRepresentativeRequest$inboundSchema
   };
   tool$representativesUpdate = {
@@ -75660,9 +76929,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: args107,
-    tool: async (client, args108, ctx) => {
-      const [result, apiCall] = await representativesUpdate(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args112,
+    tool: async (client, args113, ctx) => {
+      const [result, apiCall] = await representativesUpdate(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75677,9 +76946,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/schedulingCancel.ts
 function schedulingCancel(client, request, options) {
-  return new APIPromise($do108(client, request, options));
+  return new APIPromise($do113(client, request, options));
 }
-async function $do108(client, request, options) {
+async function $do113(client, request, options) {
   const parsed = safeParse(request, (value) => CancelScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75772,12 +77041,12 @@ var init_schedulingCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingCancel.ts
-var args108, tool$schedulingCancel;
+var args113, tool$schedulingCancel;
 var init_schedulingCancel2 = __esm(() => {
   init_schedulingCancel();
   init_operations();
   init_tools();
-  args108 = {
+  args113 = {
     request: CancelScheduleRequest$inboundSchema
   };
   tool$schedulingCancel = {
@@ -75786,9 +77055,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: args108,
-    tool: async (client, args109, ctx) => {
-      const [result, apiCall] = await schedulingCancel(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args113,
+    tool: async (client, args114, ctx) => {
+      const [result, apiCall] = await schedulingCancel(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75802,9 +77071,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/schedulingCreate.ts
 function schedulingCreate(client, request, options) {
-  return new APIPromise($do109(client, request, options));
+  return new APIPromise($do114(client, request, options));
 }
-async function $do109(client, request, options) {
+async function $do114(client, request, options) {
   const parsed = safeParse(request, (value) => CreateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75898,12 +77167,12 @@ var init_schedulingCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingCreate.ts
-var args109, tool$schedulingCreate;
+var args114, tool$schedulingCreate;
 var init_schedulingCreate2 = __esm(() => {
   init_schedulingCreate();
   init_operations();
   init_tools();
-  args109 = {
+  args114 = {
     request: CreateScheduleRequest$inboundSchema
   };
   tool$schedulingCreate = {
@@ -75912,9 +77181,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: args109,
-    tool: async (client, args110, ctx) => {
-      const [result, apiCall] = await schedulingCreate(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args114,
+    tool: async (client, args115, ctx) => {
+      const [result, apiCall] = await schedulingCreate(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75929,9 +77198,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/schedulingGet.ts
 function schedulingGet(client, request, options) {
-  return new APIPromise($do110(client, request, options));
+  return new APIPromise($do115(client, request, options));
 }
-async function $do110(client, request, options) {
+async function $do115(client, request, options) {
   const parsed = safeParse(request, (value) => GetSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76013,12 +77282,12 @@ var init_schedulingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingGet.ts
-var args110, tool$schedulingGet;
+var args115, tool$schedulingGet;
 var init_schedulingGet2 = __esm(() => {
   init_schedulingGet();
   init_operations();
   init_tools();
-  args110 = {
+  args115 = {
     request: GetSchedulesRequest$inboundSchema
   };
   tool$schedulingGet = {
@@ -76027,9 +77296,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: args110,
-    tool: async (client, args111, ctx) => {
-      const [result, apiCall] = await schedulingGet(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args115,
+    tool: async (client, args116, ctx) => {
+      const [result, apiCall] = await schedulingGet(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76044,9 +77313,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingGetOccurrance.ts
 function schedulingGetOccurrance(client, request, options) {
-  return new APIPromise($do111(client, request, options));
+  return new APIPromise($do116(client, request, options));
 }
-async function $do111(client, request, options) {
+async function $do116(client, request, options) {
   const parsed = safeParse(request, (value) => GetScheduledOccurrenceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76129,12 +77398,12 @@ var init_schedulingGetOccurrance = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingGetOccurrance.ts
-var args111, tool$schedulingGetOccurrance;
+var args116, tool$schedulingGetOccurrance;
 var init_schedulingGetOccurrance2 = __esm(() => {
   init_schedulingGetOccurrance();
   init_operations();
   init_tools();
-  args111 = {
+  args116 = {
     request: GetScheduledOccurrenceRequest$inboundSchema
   };
   tool$schedulingGetOccurrance = {
@@ -76143,9 +77412,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: args111,
-    tool: async (client, args112, ctx) => {
-      const [result, apiCall] = await schedulingGetOccurrance(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args116,
+    tool: async (client, args117, ctx) => {
+      const [result, apiCall] = await schedulingGetOccurrance(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76160,9 +77429,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingList.ts
 function schedulingList(client, request, options) {
-  return new APIPromise($do112(client, request, options));
+  return new APIPromise($do117(client, request, options));
 }
-async function $do112(client, request, options) {
+async function $do117(client, request, options) {
   const parsed = safeParse(request, (value) => ListSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76246,12 +77515,12 @@ var init_schedulingList = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingList.ts
-var args112, tool$schedulingList;
+var args117, tool$schedulingList;
 var init_schedulingList2 = __esm(() => {
   init_schedulingList();
   init_operations();
   init_tools();
-  args112 = {
+  args117 = {
     request: ListSchedulesRequest$inboundSchema
   };
   tool$schedulingList = {
@@ -76260,9 +77529,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: args112,
-    tool: async (client, args113, ctx) => {
-      const [result, apiCall] = await schedulingList(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args117,
+    tool: async (client, args118, ctx) => {
+      const [result, apiCall] = await schedulingList(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76277,9 +77546,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingUpdate.ts
 function schedulingUpdate(client, request, options) {
-  return new APIPromise($do113(client, request, options));
+  return new APIPromise($do118(client, request, options));
 }
-async function $do113(client, request, options) {
+async function $do118(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76377,12 +77646,12 @@ var init_schedulingUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingUpdate.ts
-var args113, tool$schedulingUpdate;
+var args118, tool$schedulingUpdate;
 var init_schedulingUpdate2 = __esm(() => {
   init_schedulingUpdate();
   init_operations();
   init_tools();
-  args113 = {
+  args118 = {
     request: UpdateScheduleRequest$inboundSchema
   };
   tool$schedulingUpdate = {
@@ -76391,9 +77660,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: args113,
-    tool: async (client, args114, ctx) => {
-      const [result, apiCall] = await schedulingUpdate(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args118,
+    tool: async (client, args119, ctx) => {
+      const [result, apiCall] = await schedulingUpdate(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76408,9 +77677,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/statementsGet.ts
 function statementsGet(client, request, options) {
-  return new APIPromise($do114(client, request, options));
+  return new APIPromise($do119(client, request, options));
 }
-async function $do114(client, request, options) {
+async function $do119(client, request, options) {
   const parsed = safeParse(request, (value) => GetStatementRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76496,12 +77765,12 @@ var init_statementsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/statementsGet.ts
-var args114, tool$statementsGet;
+var args119, tool$statementsGet;
 var init_statementsGet2 = __esm(() => {
   init_statementsGet();
   init_operations();
   init_tools();
-  args114 = {
+  args119 = {
     request: GetStatementRequest$inboundSchema
   };
   tool$statementsGet = {
@@ -76512,9 +77781,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: args114,
-    tool: async (client, args115, ctx) => {
-      const [result, apiCall] = await statementsGet(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args119,
+    tool: async (client, args120, ctx) => {
+      const [result, apiCall] = await statementsGet(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76529,9 +77798,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/statementsList.ts
 function statementsList(client, request, options) {
-  return new APIPromise($do115(client, request, options));
+  return new APIPromise($do120(client, request, options));
 }
-async function $do115(client, request, options) {
+async function $do120(client, request, options) {
   const parsed = safeParse(request, (value) => ListStatementsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76617,12 +77886,12 @@ var init_statementsList = __esm(() => {
 });
 
 // src/mcp-server/tools/statementsList.ts
-var args115, tool$statementsList;
+var args120, tool$statementsList;
 var init_statementsList2 = __esm(() => {
   init_statementsList();
   init_operations();
   init_tools();
-  args115 = {
+  args120 = {
     request: ListStatementsRequest$inboundSchema
   };
   tool$statementsList = {
@@ -76631,9 +77900,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: args115,
-    tool: async (client, args116, ctx) => {
-      const [result, apiCall] = await statementsList(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args120,
+    tool: async (client, args121, ctx) => {
+      const [result, apiCall] = await statementsList(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76648,9 +77917,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/supportCreateTicket.ts
 function supportCreateTicket(client, request, options) {
-  return new APIPromise($do116(client, request, options));
+  return new APIPromise($do121(client, request, options));
 }
-async function $do116(client, request, options) {
+async function $do121(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76742,12 +78011,12 @@ var init_supportCreateTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportCreateTicket.ts
-var args116, tool$supportCreateTicket;
+var args121, tool$supportCreateTicket;
 var init_supportCreateTicket2 = __esm(() => {
   init_supportCreateTicket();
   init_operations();
   init_tools();
-  args116 = {
+  args121 = {
     request: CreateTicketRequest$inboundSchema
   };
   tool$supportCreateTicket = {
@@ -76759,9 +78028,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: args116,
-    tool: async (client, args117, ctx) => {
-      const [result, apiCall] = await supportCreateTicket(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args121,
+    tool: async (client, args122, ctx) => {
+      const [result, apiCall] = await supportCreateTicket(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76776,9 +78045,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{acco
 
 // src/funcs/supportGetTicket.ts
 function supportGetTicket(client, request, options) {
-  return new APIPromise($do117(client, request, options));
+  return new APIPromise($do122(client, request, options));
 }
-async function $do117(client, request, options) {
+async function $do122(client, request, options) {
   const parsed = safeParse(request, (value) => GetTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76860,12 +78129,12 @@ var init_supportGetTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportGetTicket.ts
-var args117, tool$supportGetTicket;
+var args122, tool$supportGetTicket;
 var init_supportGetTicket2 = __esm(() => {
   init_supportGetTicket();
   init_operations();
   init_tools();
-  args117 = {
+  args122 = {
     request: GetTicketRequest$inboundSchema
   };
   tool$supportGetTicket = {
@@ -76877,9 +78146,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: args117,
-    tool: async (client, args118, ctx) => {
-      const [result, apiCall] = await supportGetTicket(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args122,
+    tool: async (client, args123, ctx) => {
+      const [result, apiCall] = await supportGetTicket(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76894,9 +78163,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportListTicketMessages.ts
 function supportListTicketMessages(client, request, options) {
-  return new APIPromise($do118(client, request, options));
+  return new APIPromise($do123(client, request, options));
 }
-async function $do118(client, request, options) {
+async function $do123(client, request, options) {
   const parsed = safeParse(request, (value) => ListTicketMessagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76978,12 +78247,12 @@ var init_supportListTicketMessages = __esm(() => {
 });
 
 // src/mcp-server/tools/supportListTicketMessages.ts
-var args118, tool$supportListTicketMessages;
+var args123, tool$supportListTicketMessages;
 var init_supportListTicketMessages2 = __esm(() => {
   init_supportListTicketMessages();
   init_operations();
   init_tools();
-  args118 = {
+  args123 = {
     request: ListTicketMessagesRequest$inboundSchema
   };
   tool$supportListTicketMessages = {
@@ -76995,9 +78264,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: args118,
-    tool: async (client, args119, ctx) => {
-      const [result, apiCall] = await supportListTicketMessages(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args123,
+    tool: async (client, args124, ctx) => {
+      const [result, apiCall] = await supportListTicketMessages(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77012,9 +78281,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportListTickets.ts
 function supportListTickets(client, request, options) {
-  return new APIPromise($do119(client, request, options));
+  return new APIPromise($do124(client, request, options));
 }
-async function $do119(client, request, options) {
+async function $do124(client, request, options) {
   const parsed = safeParse(request, (value) => ListTicketsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77099,12 +78368,12 @@ var init_supportListTickets = __esm(() => {
 });
 
 // src/mcp-server/tools/supportListTickets.ts
-var args119, tool$supportListTickets;
+var args124, tool$supportListTickets;
 var init_supportListTickets2 = __esm(() => {
   init_supportListTickets();
   init_operations();
   init_tools();
-  args119 = {
+  args124 = {
     request: ListTicketsRequest$inboundSchema
   };
   tool$supportListTickets = {
@@ -77116,9 +78385,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: args119,
-    tool: async (client, args120, ctx) => {
-      const [result, apiCall] = await supportListTickets(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args124,
+    tool: async (client, args125, ctx) => {
+      const [result, apiCall] = await supportListTickets(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77133,9 +78402,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportUpdateTicket.ts
 function supportUpdateTicket(client, request, options) {
-  return new APIPromise($do120(client, request, options));
+  return new APIPromise($do125(client, request, options));
 }
-async function $do120(client, request, options) {
+async function $do125(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77231,12 +78500,12 @@ var init_supportUpdateTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportUpdateTicket.ts
-var args120, tool$supportUpdateTicket;
+var args125, tool$supportUpdateTicket;
 var init_supportUpdateTicket2 = __esm(() => {
   init_supportUpdateTicket();
   init_operations();
   init_tools();
-  args120 = {
+  args125 = {
     request: UpdateTicketRequest$inboundSchema
   };
   tool$supportUpdateTicket = {
@@ -77248,9 +78517,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: args120,
-    tool: async (client, args121, ctx) => {
-      const [result, apiCall] = await supportUpdateTicket(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args125,
+    tool: async (client, args126, ctx) => {
+      const [result, apiCall] = await supportUpdateTicket(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77265,9 +78534,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{acco
 
 // src/funcs/sweepsCreateConfig.ts
 function sweepsCreateConfig(client, request, options) {
-  return new APIPromise($do121(client, request, options));
+  return new APIPromise($do126(client, request, options));
 }
-async function $do121(client, request, options) {
+async function $do126(client, request, options) {
   const parsed = safeParse(request, (value) => CreateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77359,12 +78628,12 @@ var init_sweepsCreateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsCreateConfig.ts
-var args121, tool$sweepsCreateConfig;
+var args126, tool$sweepsCreateConfig;
 var init_sweepsCreateConfig2 = __esm(() => {
   init_sweepsCreateConfig();
   init_operations();
   init_tools();
-  args121 = {
+  args126 = {
     request: CreateSweepConfigRequest$inboundSchema
   };
   tool$sweepsCreateConfig = {
@@ -77373,9 +78642,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: args121,
-    tool: async (client, args122, ctx) => {
-      const [result, apiCall] = await sweepsCreateConfig(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args126,
+    tool: async (client, args127, ctx) => {
+      const [result, apiCall] = await sweepsCreateConfig(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77390,9 +78659,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/sweepsGet.ts
 function sweepsGet(client, request, options) {
-  return new APIPromise($do122(client, request, options));
+  return new APIPromise($do127(client, request, options));
 }
-async function $do122(client, request, options) {
+async function $do127(client, request, options) {
   const parsed = safeParse(request, (value) => GetSweepRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77478,12 +78747,12 @@ var init_sweepsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGet.ts
-var args122, tool$sweepsGet;
+var args127, tool$sweepsGet;
 var init_sweepsGet2 = __esm(() => {
   init_sweepsGet();
   init_operations();
   init_tools();
-  args122 = {
+  args127 = {
     request: GetSweepRequest$inboundSchema
   };
   tool$sweepsGet = {
@@ -77492,9 +78761,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: args122,
-    tool: async (client, args123, ctx) => {
-      const [result, apiCall] = await sweepsGet(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args127,
+    tool: async (client, args128, ctx) => {
+      const [result, apiCall] = await sweepsGet(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77509,9 +78778,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsGetConfig.ts
 function sweepsGetConfig(client, request, options) {
-  return new APIPromise($do123(client, request, options));
+  return new APIPromise($do128(client, request, options));
 }
-async function $do123(client, request, options) {
+async function $do128(client, request, options) {
   const parsed = safeParse(request, (value) => GetSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77593,12 +78862,12 @@ var init_sweepsGetConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGetConfig.ts
-var args123, tool$sweepsGetConfig;
+var args128, tool$sweepsGetConfig;
 var init_sweepsGetConfig2 = __esm(() => {
   init_sweepsGetConfig();
   init_operations();
   init_tools();
-  args123 = {
+  args128 = {
     request: GetSweepConfigRequest$inboundSchema
   };
   tool$sweepsGetConfig = {
@@ -77607,9 +78876,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: args123,
-    tool: async (client, args124, ctx) => {
-      const [result, apiCall] = await sweepsGetConfig(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args128,
+    tool: async (client, args129, ctx) => {
+      const [result, apiCall] = await sweepsGetConfig(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77624,9 +78893,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsList.ts
 function sweepsList(client, request, options) {
-  return new APIPromise($do124(client, request, options));
+  return new APIPromise($do129(client, request, options));
 }
-async function $do124(client, request, options) {
+async function $do129(client, request, options) {
   const parsed = safeParse(request, (value) => ListSweepsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77715,12 +78984,12 @@ var init_sweepsList = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsList.ts
-var args124, tool$sweepsList;
+var args129, tool$sweepsList;
 var init_sweepsList2 = __esm(() => {
   init_sweepsList();
   init_operations();
   init_tools();
-  args124 = {
+  args129 = {
     request: ListSweepsRequest$inboundSchema
   };
   tool$sweepsList = {
@@ -77729,9 +78998,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: args124,
-    tool: async (client, args125, ctx) => {
-      const [result, apiCall] = await sweepsList(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args129,
+    tool: async (client, args130, ctx) => {
+      const [result, apiCall] = await sweepsList(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77746,9 +79015,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsListConfigs.ts
 function sweepsListConfigs(client, request, options) {
-  return new APIPromise($do125(client, request, options));
+  return new APIPromise($do130(client, request, options));
 }
-async function $do125(client, request, options) {
+async function $do130(client, request, options) {
   const parsed = safeParse(request, (value) => ListSweepConfigsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77826,12 +79095,12 @@ var init_sweepsListConfigs = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsListConfigs.ts
-var args125, tool$sweepsListConfigs;
+var args130, tool$sweepsListConfigs;
 var init_sweepsListConfigs2 = __esm(() => {
   init_sweepsListConfigs();
   init_operations();
   init_tools();
-  args125 = {
+  args130 = {
     request: ListSweepConfigsRequest$inboundSchema
   };
   tool$sweepsListConfigs = {
@@ -77840,9 +79109,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: args125,
-    tool: async (client, args126, ctx) => {
-      const [result, apiCall] = await sweepsListConfigs(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args130,
+    tool: async (client, args131, ctx) => {
+      const [result, apiCall] = await sweepsListConfigs(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77857,9 +79126,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsUpdateConfig.ts
 function sweepsUpdateConfig(client, request, options) {
-  return new APIPromise($do126(client, request, options));
+  return new APIPromise($do131(client, request, options));
 }
-async function $do126(client, request, options) {
+async function $do131(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77955,12 +79224,12 @@ var init_sweepsUpdateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsUpdateConfig.ts
-var args126, tool$sweepsUpdateConfig;
+var args131, tool$sweepsUpdateConfig;
 var init_sweepsUpdateConfig2 = __esm(() => {
   init_sweepsUpdateConfig();
   init_operations();
   init_tools();
-  args126 = {
+  args131 = {
     request: UpdateSweepConfigRequest$inboundSchema
   };
   tool$sweepsUpdateConfig = {
@@ -77969,9 +79238,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: args126,
-    tool: async (client, args127, ctx) => {
-      const [result, apiCall] = await sweepsUpdateConfig(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args131,
+    tool: async (client, args132, ctx) => {
+      const [result, apiCall] = await sweepsUpdateConfig(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77986,9 +79255,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreate.ts
 function terminalApplicationsCreate(client, request, options) {
-  return new APIPromise($do127(client, request, options));
+  return new APIPromise($do132(client, request, options));
 }
-async function $do127(client, request, options) {
+async function $do132(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTerminalApplication$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78077,12 +79346,12 @@ var init_terminalApplicationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreate.ts
-var args127, tool$terminalApplicationsCreate;
+var args132, tool$terminalApplicationsCreate;
 var init_terminalApplicationsCreate2 = __esm(() => {
   init_terminalApplicationsCreate();
   init_components();
   init_tools();
-  args127 = {
+  args132 = {
     request: CreateTerminalApplication$inboundSchema
   };
   tool$terminalApplicationsCreate = {
@@ -78091,9 +79360,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: args127,
-    tool: async (client, args128, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreate(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args132,
+    tool: async (client, args133, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreate(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78108,9 +79377,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreateVersion.ts
 function terminalApplicationsCreateVersion(client, request, options) {
-  return new APIPromise($do128(client, request, options));
+  return new APIPromise($do133(client, request, options));
 }
-async function $do128(client, request, options) {
+async function $do133(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTerminalApplicationVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78200,12 +79469,12 @@ var init_terminalApplicationsCreateVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreateVersion.ts
-var args128, tool$terminalApplicationsCreateVersion;
+var args133, tool$terminalApplicationsCreateVersion;
 var init_terminalApplicationsCreateVersion2 = __esm(() => {
   init_terminalApplicationsCreateVersion();
   init_operations();
   init_tools();
-  args128 = {
+  args133 = {
     request: CreateTerminalApplicationVersionRequest$inboundSchema
   };
   tool$terminalApplicationsCreateVersion = {
@@ -78214,9 +79483,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: args128,
-    tool: async (client, args129, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78231,9 +79500,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsDelete.ts
 function terminalApplicationsDelete(client, request, options) {
-  return new APIPromise($do129(client, request, options));
+  return new APIPromise($do134(client, request, options));
 }
-async function $do129(client, request, options) {
+async function $do134(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78317,12 +79586,12 @@ var init_terminalApplicationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsDelete.ts
-var args129, tool$terminalApplicationsDelete;
+var args134, tool$terminalApplicationsDelete;
 var init_terminalApplicationsDelete2 = __esm(() => {
   init_terminalApplicationsDelete();
   init_operations();
   init_tools();
-  args129 = {
+  args134 = {
     request: DeleteTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsDelete = {
@@ -78331,9 +79600,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: args129,
-    tool: async (client, args130, ctx) => {
-      const [result, apiCall] = await terminalApplicationsDelete(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await terminalApplicationsDelete(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78347,9 +79616,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsGet.ts
 function terminalApplicationsGet(client, request, options) {
-  return new APIPromise($do130(client, request, options));
+  return new APIPromise($do135(client, request, options));
 }
-async function $do130(client, request, options) {
+async function $do135(client, request, options) {
   const parsed = safeParse(request, (value) => GetTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78424,12 +79693,12 @@ var init_terminalApplicationsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsGet.ts
-var args130, tool$terminalApplicationsGet;
+var args135, tool$terminalApplicationsGet;
 var init_terminalApplicationsGet2 = __esm(() => {
   init_terminalApplicationsGet();
   init_operations();
   init_tools();
-  args130 = {
+  args135 = {
     request: GetTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsGet = {
@@ -78438,9 +79707,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: args130,
-    tool: async (client, args131, ctx) => {
-      const [result, apiCall] = await terminalApplicationsGet(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await terminalApplicationsGet(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78455,9 +79724,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/terminalApplicationsList.ts
 function terminalApplicationsList(client, _request, options) {
-  return new APIPromise($do131(client, _request, options));
+  return new APIPromise($do136(client, _request, options));
 }
-async function $do131(client, _request, options) {
+async function $do136(client, _request, options) {
   const path = pathToFunc("/terminal-applications")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -78521,12 +79790,12 @@ var init_terminalApplicationsList = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsList.ts
-var args131, tool$terminalApplicationsList;
+var args136, tool$terminalApplicationsList;
 var init_terminalApplicationsList2 = __esm(() => {
   init_terminalApplicationsList();
   init_operations();
   init_tools();
-  args131 = {
+  args136 = {
     request: ListTerminalApplicationsRequest$inboundSchema
   };
   tool$terminalApplicationsList = {
@@ -78535,9 +79804,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: args131,
-    tool: async (client, args132, ctx) => {
-      const [result, apiCall] = await terminalApplicationsList(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await terminalApplicationsList(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78552,9 +79821,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/transfersCreate.ts
 function transfersCreate(client, request, options) {
-  return new APIPromise($do132(client, request, options));
+  return new APIPromise($do137(client, request, options));
 }
-async function $do132(client, request, options) {
+async function $do137(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78647,12 +79916,12 @@ var init_transfersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreate.ts
-var args132, tool$transfersCreate;
+var args137, tool$transfersCreate;
 var init_transfersCreate2 = __esm(() => {
   init_transfersCreate();
   init_operations();
   init_tools();
-  args132 = {
+  args137 = {
     request: CreateTransferRequest$inboundSchema
   };
   tool$transfersCreate = {
@@ -78663,9 +79932,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: args132,
-    tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await transfersCreate(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await transfersCreate(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78680,9 +79949,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersCreateCancellation.ts
 function transfersCreateCancellation(client, request, options) {
-  return new APIPromise($do133(client, request, options));
+  return new APIPromise($do138(client, request, options));
 }
-async function $do133(client, request, options) {
+async function $do138(client, request, options) {
   const parsed = safeParse(request, (value) => CreateCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78765,12 +80034,12 @@ var init_transfersCreateCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateCancellation.ts
-var args133, tool$transfersCreateCancellation;
+var args138, tool$transfersCreateCancellation;
 var init_transfersCreateCancellation2 = __esm(() => {
   init_transfersCreateCancellation();
   init_operations();
   init_tools();
-  args133 = {
+  args138 = {
     request: CreateCancellationRequest$inboundSchema
   };
   tool$transfersCreateCancellation = {
@@ -78779,9 +80048,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: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await transfersCreateCancellation(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args138,
+    tool: async (client, args139, ctx) => {
+      const [result, apiCall] = await transfersCreateCancellation(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78796,9 +80065,9 @@ var init_transfersCreateCancellation2 = __esm(() => {
 
 // src/funcs/transfersCreateReversal.ts
 function transfersCreateReversal(client, request, options) {
-  return new APIPromise($do134(client, request, options));
+  return new APIPromise($do139(client, request, options));
 }
-async function $do134(client, request, options) {
+async function $do139(client, request, options) {
   const parsed = safeParse(request, (value) => CreateReversalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78897,12 +80166,12 @@ var init_transfersCreateReversal = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateReversal.ts
-var args134, tool$transfersCreateReversal;
+var args139, tool$transfersCreateReversal;
 var init_transfersCreateReversal2 = __esm(() => {
   init_transfersCreateReversal();
   init_operations();
   init_tools();
-  args134 = {
+  args139 = {
     request: CreateReversalRequest$inboundSchema
   };
   tool$transfersCreateReversal = {
@@ -78913,9 +80182,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: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await transfersCreateReversal(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args139,
+    tool: async (client, args140, ctx) => {
+      const [result, apiCall] = await transfersCreateReversal(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78930,9 +80199,9 @@ to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGenerateOptions.ts
 function transfersGenerateOptions(client, request, options) {
-  return new APIPromise($do135(client, request, options));
+  return new APIPromise($do140(client, request, options));
 }
-async function $do135(client, request, options) {
+async function $do140(client, request, options) {
   const parsed = safeParse(request, (value) => CreateTransferOptionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79016,12 +80285,12 @@ var init_transfersGenerateOptions = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGenerateOptions.ts
-var args135, tool$transfersGenerateOptions;
+var args140, tool$transfersGenerateOptions;
 var init_transfersGenerateOptions2 = __esm(() => {
   init_transfersGenerateOptions();
   init_operations();
   init_tools();
-  args135 = {
+  args140 = {
     request: CreateTransferOptionsRequest$inboundSchema
   };
   tool$transfersGenerateOptions = {
@@ -79035,9 +80304,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: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await transfersGenerateOptions(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args140,
+    tool: async (client, args141, ctx) => {
+      const [result, apiCall] = await transfersGenerateOptions(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79052,9 +80321,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGet.ts
 function transfersGet(client, request, options) {
-  return new APIPromise($do136(client, request, options));
+  return new APIPromise($do141(client, request, options));
 }
-async function $do136(client, request, options) {
+async function $do141(client, request, options) {
   const parsed = safeParse(request, (value) => GetTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79136,12 +80405,12 @@ var init_transfersGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGet.ts
-var args136, tool$transfersGet;
+var args141, tool$transfersGet;
 var init_transfersGet2 = __esm(() => {
   init_transfersGet();
   init_operations();
   init_tools();
-  args136 = {
+  args141 = {
     request: GetTransferRequest$inboundSchema
   };
   tool$transfersGet = {
@@ -79153,9 +80422,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: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await transfersGet(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args141,
+    tool: async (client, args142, ctx) => {
+      const [result, apiCall] = await transfersGet(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79170,9 +80439,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersGetCancellation.ts
 function transfersGetCancellation(client, request, options) {
-  return new APIPromise($do137(client, request, options));
+  return new APIPromise($do142(client, request, options));
 }
-async function $do137(client, request, options) {
+async function $do142(client, request, options) {
   const parsed = safeParse(request, (value) => GetCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79258,12 +80527,12 @@ var init_transfersGetCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetCancellation.ts
-var args137, tool$transfersGetCancellation;
+var args142, tool$transfersGetCancellation;
 var init_transfersGetCancellation2 = __esm(() => {
   init_transfersGetCancellation();
   init_operations();
   init_tools();
-  args137 = {
+  args142 = {
     request: GetCancellationRequest$inboundSchema
   };
   tool$transfersGetCancellation = {
@@ -79272,9 +80541,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: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await transfersGetCancellation(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args142,
+    tool: async (client, args143, ctx) => {
+      const [result, apiCall] = await transfersGetCancellation(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79289,9 +80558,9 @@ var init_transfersGetCancellation2 = __esm(() => {
 
 // src/funcs/transfersGetRefund.ts
 function transfersGetRefund(client, request, options) {
-  return new APIPromise($do138(client, request, options));
+  return new APIPromise($do143(client, request, options));
 }
-async function $do138(client, request, options) {
+async function $do143(client, request, options) {
   const parsed = safeParse(request, (value) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79377,12 +80646,12 @@ var init_transfersGetRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetRefund.ts
-var args138, tool$transfersGetRefund;
+var args143, tool$transfersGetRefund;
 var init_transfersGetRefund2 = __esm(() => {
   init_transfersGetRefund();
   init_operations();
   init_tools();
-  args138 = {
+  args143 = {
     request: GetRefundRequest$inboundSchema
   };
   tool$transfersGetRefund = {
@@ -79391,9 +80660,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: args138,
-    tool: async (client, args139, ctx) => {
-      const [result, apiCall] = await transfersGetRefund(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args143,
+    tool: async (client, args144, ctx) => {
+      const [result, apiCall] = await transfersGetRefund(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79408,9 +80677,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersInitiateRefund.ts
 function transfersInitiateRefund(client, request, options) {
-  return new APIPromise($do139(client, request, options));
+  return new APIPromise($do144(client, request, options));
 }
-async function $do139(client, request, options) {
+async function $do144(client, request, options) {
   const parsed = safeParse(request, (value) => InitiateRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79502,12 +80771,12 @@ var init_transfersInitiateRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersInitiateRefund.ts
-var args139, tool$transfersInitiateRefund;
+var args144, tool$transfersInitiateRefund;
 var init_transfersInitiateRefund2 = __esm(() => {
   init_transfersInitiateRefund();
   init_operations();
   init_tools();
-  args139 = {
+  args144 = {
     request: InitiateRefundRequest$inboundSchema
   };
   tool$transfersInitiateRefund = {
@@ -79519,9 +80788,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: args139,
-    tool: async (client, args140, ctx) => {
-      const [result, apiCall] = await transfersInitiateRefund(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args144,
+    tool: async (client, args145, ctx) => {
+      const [result, apiCall] = await transfersInitiateRefund(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79536,9 +80805,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersList.ts
 function transfersList(client, request, options) {
-  return new APIPromise($do140(client, request, options));
+  return new APIPromise($do145(client, request, options));
 }
-async function $do140(client, request, options) {
+async function $do145(client, request, options) {
   const parsed = safeParse(request, (value) => ListTransfersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79634,12 +80903,12 @@ var init_transfersList = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersList.ts
-var args140, tool$transfersList;
+var args145, tool$transfersList;
 var init_transfersList2 = __esm(() => {
   init_transfersList();
   init_operations();
   init_tools();
-  args140 = {
+  args145 = {
     request: ListTransfersRequest$inboundSchema
   };
   tool$transfersList = {
@@ -79655,9 +80924,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: args140,
-    tool: async (client, args141, ctx) => {
-      const [result, apiCall] = await transfersList(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args145,
+    tool: async (client, args146, ctx) => {
+      const [result, apiCall] = await transfersList(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79672,9 +80941,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersListRefunds.ts
 function transfersListRefunds(client, request, options) {
-  return new APIPromise($do141(client, request, options));
+  return new APIPromise($do146(client, request, options));
 }
-async function $do141(client, request, options) {
+async function $do146(client, request, options) {
   const parsed = safeParse(request, (value) => ListRefundsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79756,12 +81025,12 @@ var init_transfersListRefunds = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersListRefunds.ts
-var args141, tool$transfersListRefunds;
+var args146, tool$transfersListRefunds;
 var init_transfersListRefunds2 = __esm(() => {
   init_transfersListRefunds();
   init_operations();
   init_tools();
-  args141 = {
+  args146 = {
     request: ListRefundsRequest$inboundSchema
   };
   tool$transfersListRefunds = {
@@ -79770,9 +81039,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: args141,
-    tool: async (client, args142, ctx) => {
-      const [result, apiCall] = await transfersListRefunds(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args146,
+    tool: async (client, args147, ctx) => {
+      const [result, apiCall] = await transfersListRefunds(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79787,9 +81056,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersUpdate.ts
 function transfersUpdate(client, request, options) {
-  return new APIPromise($do142(client, request, options));
+  return new APIPromise($do147(client, request, options));
 }
-async function $do142(client, request, options) {
+async function $do147(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79875,12 +81144,12 @@ var init_transfersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersUpdate.ts
-var args142, tool$transfersUpdate;
+var args147, tool$transfersUpdate;
 var init_transfersUpdate2 = __esm(() => {
   init_transfersUpdate();
   init_operations();
   init_tools();
-  args142 = {
+  args147 = {
     request: UpdateTransferRequest$inboundSchema
   };
   tool$transfersUpdate = {
@@ -79891,9 +81160,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: args142,
-    tool: async (client, args143, ctx) => {
-      const [result, apiCall] = await transfersUpdate(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args147,
+    tool: async (client, args148, ctx) => {
+      const [result, apiCall] = await transfersUpdate(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79908,9 +81177,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/underwritingGet.ts
 function underwritingGet(client, request, options) {
-  return new APIPromise($do143(client, request, options));
+  return new APIPromise($do148(client, request, options));
 }
-async function $do143(client, request, options) {
+async function $do148(client, request, options) {
   const parsed = safeParse(request, (value) => GetUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79988,12 +81257,12 @@ var init_underwritingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingGet.ts
-var args143, tool$underwritingGet;
+var args148, tool$underwritingGet;
 var init_underwritingGet2 = __esm(() => {
   init_underwritingGet();
   init_operations();
   init_tools();
-  args143 = {
+  args148 = {
     request: GetUnderwritingRequest$inboundSchema
   };
   tool$underwritingGet = {
@@ -80004,9 +81273,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: args143,
-    tool: async (client, args144, ctx) => {
-      const [result, apiCall] = await underwritingGet(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args148,
+    tool: async (client, args149, ctx) => {
+      const [result, apiCall] = await underwritingGet(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80021,9 +81290,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/underwritingSave.ts
 function underwritingSave(client, request, options) {
-  return new APIPromise($do144(client, request, options));
+  return new APIPromise($do149(client, request, options));
 }
-async function $do144(client, request, options) {
+async function $do149(client, request, options) {
   const parsed = safeParse(request, (value) => SaveUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80119,12 +81388,12 @@ var init_underwritingSave = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingSave.ts
-var args144, tool$underwritingSave;
+var args149, tool$underwritingSave;
 var init_underwritingSave2 = __esm(() => {
   init_underwritingSave();
   init_operations();
   init_tools();
-  args144 = {
+  args149 = {
     request: SaveUnderwritingRequest$inboundSchema
   };
   tool$underwritingSave = {
@@ -80135,9 +81404,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: args144,
-    tool: async (client, args145, ctx) => {
-      const [result, apiCall] = await underwritingSave(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args149,
+    tool: async (client, args150, ctx) => {
+      const [result, apiCall] = await underwritingSave(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80152,9 +81421,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/underwritingUpsert.ts
 function underwritingUpsert(client, request, options) {
-  return new APIPromise($do145(client, request, options));
+  return new APIPromise($do150(client, request, options));
 }
-async function $do145(client, request, options) {
+async function $do150(client, request, options) {
   const parsed = safeParse(request, (value) => UpsertUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80250,12 +81519,12 @@ var init_underwritingUpsert = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingUpsert.ts
-var args145, tool$underwritingUpsert;
+var args150, tool$underwritingUpsert;
 var init_underwritingUpsert2 = __esm(() => {
   init_underwritingUpsert();
   init_operations();
   init_tools();
-  args145 = {
+  args150 = {
     request: UpsertUnderwritingRequest$inboundSchema
   };
   tool$underwritingUpsert = {
@@ -80266,9 +81535,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: args145,
-    tool: async (client, args146, ctx) => {
-      const [result, apiCall] = await underwritingUpsert(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args150,
+    tool: async (client, args151, ctx) => {
+      const [result, apiCall] = await underwritingUpsert(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80283,9 +81552,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/walletsCreate.ts
 function walletsCreate(client, request, options) {
-  return new APIPromise($do146(client, request, options));
+  return new APIPromise($do151(client, request, options));
 }
-async function $do146(client, request, options) {
+async function $do151(client, request, options) {
   const parsed = safeParse(request, (value) => CreateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80379,12 +81648,12 @@ var init_walletsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsCreate.ts
-var args146, tool$walletsCreate;
+var args151, tool$walletsCreate;
 var init_walletsCreate2 = __esm(() => {
   init_walletsCreate();
   init_operations();
   init_tools();
-  args146 = {
+  args151 = {
     request: CreateWalletRequest$inboundSchema
   };
   tool$walletsCreate = {
@@ -80395,9 +81664,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: args146,
-    tool: async (client, args147, ctx) => {
-      const [result, apiCall] = await walletsCreate(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args151,
+    tool: async (client, args152, ctx) => {
+      const [result, apiCall] = await walletsCreate(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80412,9 +81681,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletsGet.ts
 function walletsGet(client, request, options) {
-  return new APIPromise($do147(client, request, options));
+  return new APIPromise($do152(client, request, options));
 }
-async function $do147(client, request, options) {
+async function $do152(client, request, options) {
   const parsed = safeParse(request, (value) => GetWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80496,12 +81765,12 @@ var init_walletsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsGet.ts
-var args147, tool$walletsGet;
+var args152, tool$walletsGet;
 var init_walletsGet2 = __esm(() => {
   init_walletsGet();
   init_operations();
   init_tools();
-  args147 = {
+  args152 = {
     request: GetWalletRequest$inboundSchema
   };
   tool$walletsGet = {
@@ -80512,9 +81781,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: args147,
-    tool: async (client, args148, ctx) => {
-      const [result, apiCall] = await walletsGet(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args152,
+    tool: async (client, args153, ctx) => {
+      const [result, apiCall] = await walletsGet(client, args153.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80529,9 +81798,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsList.ts
 function walletsList(client, request, options) {
-  return new APIPromise($do148(client, request, options));
+  return new APIPromise($do153(client, request, options));
 }
-async function $do148(client, request, options) {
+async function $do153(client, request, options) {
   const parsed = safeParse(request, (value) => ListWalletsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80619,12 +81888,12 @@ var init_walletsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsList.ts
-var args148, tool$walletsList;
+var args153, tool$walletsList;
 var init_walletsList2 = __esm(() => {
   init_walletsList();
   init_operations();
   init_tools();
-  args148 = {
+  args153 = {
     request: ListWalletsRequest$inboundSchema
   };
   tool$walletsList = {
@@ -80635,9 +81904,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: args148,
-    tool: async (client, args149, ctx) => {
-      const [result, apiCall] = await walletsList(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args153,
+    tool: async (client, args154, ctx) => {
+      const [result, apiCall] = await walletsList(client, args154.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80652,9 +81921,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsUpdate.ts
 function walletsUpdate(client, request, options) {
-  return new APIPromise($do149(client, request, options));
+  return new APIPromise($do154(client, request, options));
 }
-async function $do149(client, request, options) {
+async function $do154(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80752,12 +82021,12 @@ var init_walletsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsUpdate.ts
-var args149, tool$walletsUpdate;
+var args154, tool$walletsUpdate;
 var init_walletsUpdate2 = __esm(() => {
   init_walletsUpdate();
   init_operations();
   init_tools();
-  args149 = {
+  args154 = {
     request: UpdateWalletRequest$inboundSchema
   };
   tool$walletsUpdate = {
@@ -80768,9 +82037,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: args149,
-    tool: async (client, args150, ctx) => {
-      const [result, apiCall] = await walletsUpdate(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args154,
+    tool: async (client, args155, ctx) => {
+      const [result, apiCall] = await walletsUpdate(client, args155.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80785,9 +82054,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletTransactionsGet.ts
 function walletTransactionsGet(client, request, options) {
-  return new APIPromise($do150(client, request, options));
+  return new APIPromise($do155(client, request, options));
 }
-async function $do150(client, request, options) {
+async function $do155(client, request, options) {
   const parsed = safeParse(request, (value) => GetWalletTransactionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -80873,12 +82142,12 @@ var init_walletTransactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsGet.ts
-var args150, tool$walletTransactionsGet;
+var args155, tool$walletTransactionsGet;
 var init_walletTransactionsGet2 = __esm(() => {
   init_walletTransactionsGet();
   init_operations();
   init_tools();
-  args150 = {
+  args155 = {
     request: GetWalletTransactionRequest$inboundSchema
   };
   tool$walletTransactionsGet = {
@@ -80889,9 +82158,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: args150,
-    tool: async (client, args151, ctx) => {
-      const [result, apiCall] = await walletTransactionsGet(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args155,
+    tool: async (client, args156, ctx) => {
+      const [result, apiCall] = await walletTransactionsGet(client, args156.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -80906,9 +82175,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletTransactionsList.ts
 function walletTransactionsList(client, request, options) {
-  return new APIPromise($do151(client, request, options));
+  return new APIPromise($do156(client, request, options));
 }
-async function $do151(client, request, options) {
+async function $do156(client, request, options) {
   const parsed = safeParse(request, (value) => ListWalletTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -81008,12 +82277,12 @@ var init_walletTransactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsList.ts
-var args151, tool$walletTransactionsList;
+var args156, tool$walletTransactionsList;
 var init_walletTransactionsList2 = __esm(() => {
   init_walletTransactionsList();
   init_operations();
   init_tools();
-  args151 = {
+  args156 = {
     request: ListWalletTransactionsRequest$inboundSchema
   };
   tool$walletTransactionsList = {
@@ -81024,9 +82293,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: args151,
-    tool: async (client, args152, ctx) => {
-      const [result, apiCall] = await walletTransactionsList(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args156,
+    tool: async (client, args157, ctx) => {
+      const [result, apiCall] = await walletTransactionsList(client, args157.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -81043,7 +82312,7 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Moov",
-    version: "0.16.4"
+    version: "0.16.5"
   });
   const client = new MoovCore({
     security: deps.security,
@@ -81129,6 +82398,11 @@ function createMCPServer(deps) {
   tool(tool$paymentLinksGetQRCode);
   tool(tool$paymentMethodsList);
   tool(tool$paymentMethodsGet);
+  tool(tool$productsList);
+  tool(tool$productsCreate);
+  tool(tool$productsGet);
+  tool(tool$productsUpdate);
+  tool(tool$productsDisable);
   tool(tool$representativesCreate);
   tool(tool$representativesList);
   tool(tool$representativesDelete);
@@ -81316,6 +82590,11 @@ var init_server2 = __esm(() => {
   init_paymentMethodsGet2();
   init_paymentMethodsList2();
   init_pingPing2();
+  init_productsCreate2();
+  init_productsDisable2();
+  init_productsGet2();
+  init_productsList2();
+  init_productsUpdate2();
   init_receiptsCreate2();
   init_receiptsList2();
   init_representativesCreate2();
@@ -82569,7 +83848,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.16.4"
+    currentVersion: "0.16.5"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -82577,5 +83856,5 @@ export {
   app
 };
 
-//# debugId=C74A1EB3FD86849F64756E2164756E21
+//# debugId=FB9192464406F64164756E2164756E21
 //# sourceMappingURL=mcp-server.js.map