@moovio/sdk 0.21.14 → 0.21.15

package/bin/mcp-server.js

@@ -34030,9 +34030,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "latest",
-    sdkVersion: "0.21.14",
+    sdkVersion: "0.21.15",
     genVersion: "2.755.9",
-    userAgent: "speakeasy-sdk/typescript 0.21.14 2.755.9 latest @moovio/sdk"
+    userAgent: "speakeasy-sdk/typescript 0.21.15 2.755.9 latest @moovio/sdk"
   };
 });
 
@@ -37029,6 +37029,20 @@ var init_amount = __esm(() => {
   });
 });
 
+// src/models/components/amountdecimalupdate.ts
+var AmountDecimalUpdate$inboundSchema, AmountDecimalUpdate$outboundSchema;
+var init_amountdecimalupdate = __esm(() => {
+  init_esm();
+  AmountDecimalUpdate$inboundSchema = objectType({
+    currency: stringType().optional(),
+    valueDecimal: stringType().optional()
+  });
+  AmountDecimalUpdate$outboundSchema = objectType({
+    currency: stringType().optional(),
+    valueDecimal: stringType().optional()
+  });
+});
+
 // src/models/components/amountdecimalvalidationerror.ts
 var AmountDecimalValidationError$inboundSchema, AmountDecimalValidationError$outboundSchema;
 var init_amountdecimalvalidationerror = __esm(() => {
@@ -42519,6 +42533,84 @@ var init_createindividualerror = __esm(() => {
   });
 });
 
+// src/models/components/invoicelineitemoption.ts
+var InvoiceLineItemOption$inboundSchema, InvoiceLineItemOption$outboundSchema;
+var init_invoicelineitemoption = __esm(() => {
+  init_esm();
+  init_amountdecimal();
+  InvoiceLineItemOption$inboundSchema = objectType({
+    name: stringType(),
+    quantity: numberType().int(),
+    priceModifier: AmountDecimal$inboundSchema.optional(),
+    group: stringType().optional()
+  });
+  InvoiceLineItemOption$outboundSchema = objectType({
+    name: stringType(),
+    quantity: numberType().int(),
+    priceModifier: AmountDecimal$outboundSchema.optional(),
+    group: stringType().optional()
+  });
+});
+
+// src/models/components/invoicelineitem.ts
+var InvoiceLineItem$inboundSchema, InvoiceLineItem$outboundSchema;
+var init_invoicelineitem = __esm(() => {
+  init_esm();
+  init_amountdecimal();
+  init_invoicelineitemoption();
+  InvoiceLineItem$inboundSchema = objectType({
+    name: stringType(),
+    basePrice: AmountDecimal$inboundSchema,
+    quantity: numberType().int(),
+    options: arrayType(InvoiceLineItemOption$inboundSchema).optional(),
+    productID: stringType().optional()
+  });
+  InvoiceLineItem$outboundSchema = objectType({
+    name: stringType(),
+    basePrice: AmountDecimal$outboundSchema,
+    quantity: numberType().int(),
+    options: arrayType(InvoiceLineItemOption$outboundSchema).optional(),
+    productID: stringType().optional()
+  });
+});
+
+// src/models/components/invoicelineitems.ts
+var InvoiceLineItems$inboundSchema, InvoiceLineItems$outboundSchema;
+var init_invoicelineitems = __esm(() => {
+  init_esm();
+  init_invoicelineitem();
+  InvoiceLineItems$inboundSchema = objectType({
+    items: arrayType(InvoiceLineItem$inboundSchema)
+  });
+  InvoiceLineItems$outboundSchema = objectType({
+    items: arrayType(InvoiceLineItem$outboundSchema)
+  });
+});
+
+// src/models/components/createinvoice.ts
+var CreateInvoice$inboundSchema, CreateInvoice$outboundSchema;
+var init_createinvoice = __esm(() => {
+  init_esm();
+  init_amountdecimal();
+  init_invoicelineitems();
+  CreateInvoice$inboundSchema = objectType({
+    customerAccountID: stringType(),
+    description: stringType(),
+    lineItems: InvoiceLineItems$inboundSchema,
+    invoiceDate: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    dueDate: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    taxAmount: AmountDecimal$inboundSchema.optional()
+  });
+  CreateInvoice$outboundSchema = objectType({
+    customerAccountID: stringType(),
+    description: stringType(),
+    lineItems: InvoiceLineItems$outboundSchema,
+    invoiceDate: dateType().transform((v2) => v2.toISOString()).optional(),
+    dueDate: dateType().transform((v2) => v2.toISOString()).optional(),
+    taxAmount: AmountDecimal$outboundSchema.optional()
+  });
+});
+
 // src/models/components/paymentlinkcustomeroptions.ts
 var PaymentLinkCustomerOptions$inboundSchema, PaymentLinkCustomerOptions$outboundSchema;
 var init_paymentlinkcustomeroptions = __esm(() => {
@@ -44237,6 +44329,216 @@ var init_institutionssearchresponse = __esm(() => {
   });
 });
 
+// src/models/components/invoiceexternalpayment.ts
+var InvoiceExternalPaymentPaymentType, InvoiceExternalPaymentPaymentType$inboundSchema, InvoiceExternalPaymentPaymentType$outboundSchema, InvoiceExternalPayment$inboundSchema, InvoiceExternalPayment$outboundSchema;
+var init_invoiceexternalpayment = __esm(() => {
+  init_esm();
+  init_amountdecimal();
+  InvoiceExternalPaymentPaymentType = {
+    External: "external"
+  };
+  InvoiceExternalPaymentPaymentType$inboundSchema = nativeEnumType(InvoiceExternalPaymentPaymentType);
+  InvoiceExternalPaymentPaymentType$outboundSchema = InvoiceExternalPaymentPaymentType$inboundSchema;
+  InvoiceExternalPayment$inboundSchema = objectType({
+    paymentType: InvoiceExternalPaymentPaymentType$inboundSchema,
+    description: stringType(),
+    foreignID: stringType().optional(),
+    paymentDate: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    amount: AmountDecimal$inboundSchema
+  });
+  InvoiceExternalPayment$outboundSchema = objectType({
+    paymentType: InvoiceExternalPaymentPaymentType$outboundSchema,
+    description: stringType(),
+    foreignID: stringType().optional(),
+    paymentDate: dateType().transform((v2) => v2.toISOString()).optional(),
+    amount: AmountDecimal$outboundSchema
+  });
+});
+
+// src/models/components/invoicetransferpayment.ts
+var PaymentType, PaymentType$inboundSchema, PaymentType$outboundSchema, InvoiceTransferPayment$inboundSchema, InvoiceTransferPayment$outboundSchema;
+var init_invoicetransferpayment = __esm(() => {
+  init_esm();
+  PaymentType = {
+    Transfer: "transfer"
+  };
+  PaymentType$inboundSchema = nativeEnumType(PaymentType);
+  PaymentType$outboundSchema = PaymentType$inboundSchema;
+  InvoiceTransferPayment$inboundSchema = objectType({
+    paymentType: PaymentType$inboundSchema,
+    transferID: stringType()
+  });
+  InvoiceTransferPayment$outboundSchema = objectType({
+    paymentType: PaymentType$outboundSchema,
+    transferID: stringType()
+  });
+});
+
+// src/models/components/invoicepayment.ts
+var InvoicePayment$inboundSchema, InvoicePayment$outboundSchema;
+var init_invoicepayment = __esm(() => {
+  init_esm();
+  init_invoiceexternalpayment();
+  init_invoicetransferpayment();
+  InvoicePayment$inboundSchema = unionType([
+    InvoiceExternalPayment$inboundSchema.and(objectType({ paymentType: literalType("external") }).transform((v2) => ({
+      paymentType: v2.paymentType
+    }))),
+    InvoiceTransferPayment$inboundSchema.and(objectType({ paymentType: literalType("transfer") }).transform((v2) => ({
+      paymentType: v2.paymentType
+    })))
+  ]);
+  InvoicePayment$outboundSchema = unionType([
+    InvoiceExternalPayment$outboundSchema.and(objectType({ paymentType: literalType("external") }).transform((v2) => ({
+      paymentType: v2.paymentType
+    }))),
+    InvoiceTransferPayment$outboundSchema.and(objectType({ paymentType: literalType("transfer") }).transform((v2) => ({
+      paymentType: v2.paymentType
+    })))
+  ]);
+});
+
+// src/models/components/invoicestatus.ts
+var InvoiceStatus, InvoiceStatus$inboundSchema, InvoiceStatus$outboundSchema;
+var init_invoicestatus = __esm(() => {
+  init_esm();
+  InvoiceStatus = {
+    Draft: "draft",
+    Unpaid: "unpaid",
+    PaymentPending: "payment-pending",
+    Paid: "paid",
+    Overdue: "overdue",
+    Canceled: "canceled"
+  };
+  InvoiceStatus$inboundSchema = nativeEnumType(InvoiceStatus);
+  InvoiceStatus$outboundSchema = InvoiceStatus$inboundSchema;
+});
+
+// src/models/components/invoice.ts
+var Invoice$inboundSchema, Invoice$outboundSchema;
+var init_invoice = __esm(() => {
+  init_esm();
+  init_amountdecimal();
+  init_invoicelineitems();
+  init_invoicepayment();
+  init_invoicestatus();
+  Invoice$inboundSchema = objectType({
+    invoiceID: stringType(),
+    invoiceNumber: stringType(),
+    description: stringType(),
+    customerAccountID: stringType(),
+    partnerAccountID: stringType(),
+    status: InvoiceStatus$inboundSchema,
+    lineItems: InvoiceLineItems$inboundSchema,
+    subtotalAmount: AmountDecimal$inboundSchema,
+    taxAmount: AmountDecimal$inboundSchema,
+    totalAmount: AmountDecimal$inboundSchema,
+    pendingAmount: AmountDecimal$inboundSchema,
+    paidAmount: AmountDecimal$inboundSchema,
+    refundedAmount: AmountDecimal$inboundSchema,
+    disputedAmount: AmountDecimal$inboundSchema,
+    paymentLinkCode: stringType().optional(),
+    payments: arrayType(InvoicePayment$inboundSchema).optional(),
+    createdOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    invoiceDate: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    dueDate: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    sentOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    paidOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    canceledOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional()
+  });
+  Invoice$outboundSchema = objectType({
+    invoiceID: stringType(),
+    invoiceNumber: stringType(),
+    description: stringType(),
+    customerAccountID: stringType(),
+    partnerAccountID: stringType(),
+    status: InvoiceStatus$outboundSchema,
+    lineItems: InvoiceLineItems$outboundSchema,
+    subtotalAmount: AmountDecimal$outboundSchema,
+    taxAmount: AmountDecimal$outboundSchema,
+    totalAmount: AmountDecimal$outboundSchema,
+    pendingAmount: AmountDecimal$outboundSchema,
+    paidAmount: AmountDecimal$outboundSchema,
+    refundedAmount: AmountDecimal$outboundSchema,
+    disputedAmount: AmountDecimal$outboundSchema,
+    paymentLinkCode: stringType().optional(),
+    payments: arrayType(InvoicePayment$outboundSchema).optional(),
+    createdOn: dateType().transform((v2) => v2.toISOString()),
+    invoiceDate: dateType().transform((v2) => v2.toISOString()).optional(),
+    dueDate: dateType().transform((v2) => v2.toISOString()).optional(),
+    sentOn: dateType().transform((v2) => v2.toISOString()).optional(),
+    paidOn: dateType().transform((v2) => v2.toISOString()).optional(),
+    canceledOn: dateType().transform((v2) => v2.toISOString()).optional()
+  });
+});
+
+// src/models/components/invoicelineitemoptionvalidationerror.ts
+var InvoiceLineItemOptionValidationError$inboundSchema, InvoiceLineItemOptionValidationError$outboundSchema;
+var init_invoicelineitemoptionvalidationerror = __esm(() => {
+  init_esm();
+  init_amountdecimalvalidationerror();
+  InvoiceLineItemOptionValidationError$inboundSchema = objectType({
+    name: stringType().optional(),
+    group: stringType().optional(),
+    priceModifier: AmountDecimalValidationError$inboundSchema.optional(),
+    quantity: stringType().optional()
+  });
+  InvoiceLineItemOptionValidationError$outboundSchema = objectType({
+    name: stringType().optional(),
+    group: stringType().optional(),
+    priceModifier: AmountDecimalValidationError$outboundSchema.optional(),
+    quantity: stringType().optional()
+  });
+});
+
+// src/models/components/invoicelineitemsupdate.ts
+var InvoiceLineItemsUpdate$inboundSchema, InvoiceLineItemsUpdate$outboundSchema;
+var init_invoicelineitemsupdate = __esm(() => {
+  init_esm();
+  init_invoicelineitem();
+  InvoiceLineItemsUpdate$inboundSchema = objectType({
+    items: arrayType(InvoiceLineItem$inboundSchema).optional()
+  });
+  InvoiceLineItemsUpdate$outboundSchema = objectType({
+    items: arrayType(InvoiceLineItem$outboundSchema).optional()
+  });
+});
+
+// src/models/components/invoicelineitemvalidationerror.ts
+var InvoiceLineItemValidationError$inboundSchema, InvoiceLineItemValidationError$outboundSchema;
+var init_invoicelineitemvalidationerror = __esm(() => {
+  init_esm();
+  init_amountdecimalvalidationerror();
+  init_invoicelineitemoptionvalidationerror();
+  InvoiceLineItemValidationError$inboundSchema = objectType({
+    productID: stringType().optional(),
+    name: stringType().optional(),
+    basePrice: AmountDecimalValidationError$inboundSchema.optional(),
+    options: recordType(InvoiceLineItemOptionValidationError$inboundSchema).optional(),
+    quantity: stringType().optional()
+  });
+  InvoiceLineItemValidationError$outboundSchema = objectType({
+    productID: stringType().optional(),
+    name: stringType().optional(),
+    basePrice: AmountDecimalValidationError$outboundSchema.optional(),
+    options: recordType(InvoiceLineItemOptionValidationError$outboundSchema).optional(),
+    quantity: stringType().optional()
+  });
+});
+
+// src/models/components/invoicelineitemsvalidationerror.ts
+var InvoiceLineItemsValidationError$inboundSchema, InvoiceLineItemsValidationError$outboundSchema;
+var init_invoicelineitemsvalidationerror = __esm(() => {
+  init_esm();
+  init_invoicelineitemvalidationerror();
+  InvoiceLineItemsValidationError$inboundSchema = objectType({
+    items: recordType(InvoiceLineItemValidationError$inboundSchema).optional()
+  });
+  InvoiceLineItemsValidationError$outboundSchema = objectType({
+    items: recordType(InvoiceLineItemValidationError$outboundSchema).optional()
+  });
+});
+
 // src/models/components/issuedcard.ts
 var IssuedCard$inboundSchema, IssuedCard$outboundSchema;
 var init_issuedcard = __esm(() => {
@@ -44775,6 +45077,22 @@ var init_manualtermsofserviceupdate = __esm(() => {
   });
 });
 
+// src/models/components/markinvoicepaid.ts
+var MarkInvoicePaid$inboundSchema, MarkInvoicePaid$outboundSchema;
+var init_markinvoicepaid = __esm(() => {
+  init_esm();
+  MarkInvoicePaid$inboundSchema = objectType({
+    foreignID: stringType().optional(),
+    description: stringType().optional(),
+    paymentDate: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional()
+  });
+  MarkInvoicePaid$outboundSchema = objectType({
+    foreignID: stringType().optional(),
+    description: stringType().optional(),
+    paymentDate: dateType().transform((v2) => v2.toISOString()).optional()
+  });
+});
+
 // src/models/components/moneytransferpullfromcard.ts
 var MoneyTransferPullFromCard$inboundSchema, MoneyTransferPullFromCard$outboundSchema;
 var init_moneytransferpullfromcard = __esm(() => {
@@ -47341,6 +47659,31 @@ var init_updateevidence = __esm(() => {
   });
 });
 
+// src/models/components/updateinvoice.ts
+var UpdateInvoice$inboundSchema, UpdateInvoice$outboundSchema;
+var init_updateinvoice = __esm(() => {
+  init_esm();
+  init_amountdecimalupdate();
+  init_invoicelineitemsupdate();
+  init_invoicestatus();
+  UpdateInvoice$inboundSchema = objectType({
+    description: stringType().optional(),
+    lineItems: InvoiceLineItemsUpdate$inboundSchema.optional(),
+    invoiceDate: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
+    dueDate: nullableType(stringType().datetime({ offset: true }).transform((v2) => new Date(v2))).optional(),
+    status: InvoiceStatus$inboundSchema.optional(),
+    taxAmount: AmountDecimalUpdate$inboundSchema.optional()
+  });
+  UpdateInvoice$outboundSchema = objectType({
+    description: stringType().optional(),
+    lineItems: InvoiceLineItemsUpdate$outboundSchema.optional(),
+    invoiceDate: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
+    dueDate: nullableType(dateType().transform((v2) => v2.toISOString())).optional(),
+    status: InvoiceStatus$outboundSchema.optional(),
+    taxAmount: AmountDecimalUpdate$outboundSchema.optional()
+  });
+});
+
 // src/models/components/updateissuedcard.ts
 var UpdateIssuedCard$inboundSchema, UpdateIssuedCard$outboundSchema;
 var init_updateissuedcard = __esm(() => {
@@ -48008,6 +48351,37 @@ var init_webhookdatadisputeupdated = __esm(() => {
   });
 });
 
+// src/models/components/webhookdatainvoicecreated.ts
+var WebhookDataInvoiceCreated$inboundSchema, WebhookDataInvoiceCreated$outboundSchema;
+var init_webhookdatainvoicecreated = __esm(() => {
+  init_esm();
+  WebhookDataInvoiceCreated$inboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType()
+  });
+  WebhookDataInvoiceCreated$outboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType()
+  });
+});
+
+// src/models/components/webhookdatainvoiceupdated.ts
+var WebhookDataInvoiceUpdated$inboundSchema, WebhookDataInvoiceUpdated$outboundSchema;
+var init_webhookdatainvoiceupdated = __esm(() => {
+  init_esm();
+  init_invoicestatus();
+  WebhookDataInvoiceUpdated$inboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType(),
+    status: InvoiceStatus$inboundSchema
+  });
+  WebhookDataInvoiceUpdated$outboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType(),
+    status: InvoiceStatus$outboundSchema
+  });
+});
+
 // src/models/components/webhookdatanetworkidupdated.ts
 var WebhookDataNetworkIDUpdated$inboundSchema, WebhookDataNetworkIDUpdated$outboundSchema;
 var init_webhookdatanetworkidupdated = __esm(() => {
@@ -48416,6 +48790,8 @@ var init_webhookdata = __esm(() => {
   init_webhookdatacardautoupdated();
   init_webhookdatadisputecreated();
   init_webhookdatadisputeupdated();
+  init_webhookdatainvoicecreated();
+  init_webhookdatainvoiceupdated();
   init_webhookdatanetworkidupdated();
   init_webhookdatapaymentmethoddisabled();
   init_webhookdatapaymentmethodenabled();
@@ -48447,6 +48823,7 @@ var init_webhookdata = __esm(() => {
     WebhookDataCancellationUpdated$inboundSchema,
     WebhookDataCardAutoUpdated$inboundSchema,
     WebhookDataCapabilityUpdated$inboundSchema,
+    WebhookDataInvoiceUpdated$inboundSchema,
     WebhookDataPaymentMethodEnabled$inboundSchema,
     WebhookDataPaymentMethodDisabled$inboundSchema,
     WebhookDataRefundCreated$inboundSchema,
@@ -48458,6 +48835,7 @@ var init_webhookdata = __esm(() => {
     WebhookDataBankAccountCreated$inboundSchema,
     WebhookDataBankAccountDeleted$inboundSchema,
     WebhookDataCapabilityRequested$inboundSchema,
+    WebhookDataInvoiceCreated$inboundSchema,
     WebhookDataRepresentativeCreated$inboundSchema,
     WebhookDataRepresentativeUpdated$inboundSchema,
     WebhookDataRepresentativeDisabled$inboundSchema,
@@ -48484,6 +48862,7 @@ var init_webhookdata = __esm(() => {
     WebhookDataCancellationUpdated$outboundSchema,
     WebhookDataCardAutoUpdated$outboundSchema,
     WebhookDataCapabilityUpdated$outboundSchema,
+    WebhookDataInvoiceUpdated$outboundSchema,
     WebhookDataPaymentMethodEnabled$outboundSchema,
     WebhookDataPaymentMethodDisabled$outboundSchema,
     WebhookDataRefundCreated$outboundSchema,
@@ -48495,6 +48874,7 @@ var init_webhookdata = __esm(() => {
     WebhookDataBankAccountCreated$outboundSchema,
     WebhookDataBankAccountDeleted$outboundSchema,
     WebhookDataCapabilityRequested$outboundSchema,
+    WebhookDataInvoiceCreated$outboundSchema,
     WebhookDataRepresentativeCreated$outboundSchema,
     WebhookDataRepresentativeUpdated$outboundSchema,
     WebhookDataRepresentativeDisabled$outboundSchema,
@@ -48532,6 +48912,8 @@ var init_webhookeventtype = __esm(() => {
     CapabilityUpdated: "capability.updated",
     DisputeCreated: "dispute.created",
     DisputeUpdated: "dispute.updated",
+    InvoiceCreated: "invoice.created",
+    InvoiceUpdated: "invoice.updated",
     NetworkIDUpdated: "networkID.updated",
     PaymentMethodEnabled: "paymentMethod.enabled",
     PaymentMethodDisabled: "paymentMethod.disabled",
@@ -48610,6 +48992,7 @@ var init_components = __esm(() => {
   init_adjustment();
   init_amount();
   init_amountdecimal();
+  init_amountdecimalupdate();
   init_amountdecimalvalidationerror();
   init_amountupdate();
   init_amountvalidationerror();
@@ -48719,6 +49102,7 @@ var init_components = __esm(() => {
   init_createfeeplanagreement();
   init_createindividualerror();
   init_createindividualprofile();
+  init_createinvoice();
   init_createpaymentlink();
   init_createproductoption();
   init_createproductoptiongroup();
@@ -48811,6 +49195,18 @@ var init_components = __esm(() => {
   init_instantbankcreditpaymentmethod();
   init_instantpaymentfees();
   init_institutionssearchresponse();
+  init_invoice();
+  init_invoiceexternalpayment();
+  init_invoicelineitem();
+  init_invoicelineitemoption();
+  init_invoicelineitemoptionvalidationerror();
+  init_invoicelineitems();
+  init_invoicelineitemsupdate();
+  init_invoicelineitemsvalidationerror();
+  init_invoicelineitemvalidationerror();
+  init_invoicepayment();
+  init_invoicestatus();
+  init_invoicetransferpayment();
   init_issuedcard();
   init_issuedcardauthorization();
   init_issuedcardauthorizationevent();
@@ -48840,6 +49236,7 @@ var init_components = __esm(() => {
   init_listfeesfetchrequest();
   init_manualtermsofservice();
   init_manualtermsofserviceupdate();
+  init_markinvoicepaid();
   init_microdepositstatus();
   init_minimumcommitment();
   init_mode();
@@ -49019,6 +49416,7 @@ var init_components = __esm(() => {
   init_updatecolor();
   init_updatecolors();
   init_updateevidence();
+  init_updateinvoice();
   init_updateissuedcard();
   init_updatepaymentlink();
   init_updaterepresentative();
@@ -49059,6 +49457,8 @@ var init_components = __esm(() => {
   init_webhookdatacardautoupdated();
   init_webhookdatadisputecreated();
   init_webhookdatadisputeupdated();
+  init_webhookdatainvoicecreated();
+  init_webhookdatainvoiceupdated();
   init_webhookdatanetworkidupdated();
   init_webhookdatapaymentmethoddisabled();
   init_webhookdatapaymentmethodenabled();
@@ -49247,6 +49647,67 @@ var init_createaccounterror = __esm(() => {
   }));
 });
 
+// src/models/errors/createinvoiceerror.ts
+var CreateInvoiceError, CreateInvoiceError$inboundSchema, CreateInvoiceError$outboundSchema;
+var init_createinvoiceerror = __esm(() => {
+  init_esm();
+  init_components();
+  init_mooverror();
+  CreateInvoiceError = class CreateInvoiceError extends MoovError {
+    customerAccountID;
+    description;
+    lineItems;
+    invoiceDate;
+    dueDate;
+    taxAmount;
+    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.customerAccountID != null) {
+        this.customerAccountID = err.customerAccountID;
+      }
+      if (err.description != null)
+        this.description = err.description;
+      if (err.lineItems != null)
+        this.lineItems = err.lineItems;
+      if (err.invoiceDate != null)
+        this.invoiceDate = err.invoiceDate;
+      if (err.dueDate != null)
+        this.dueDate = err.dueDate;
+      if (err.taxAmount != null)
+        this.taxAmount = err.taxAmount;
+      this.name = "CreateInvoiceError";
+    }
+  };
+  CreateInvoiceError$inboundSchema = objectType({
+    customerAccountID: stringType().optional(),
+    description: stringType().optional(),
+    lineItems: InvoiceLineItemsValidationError$inboundSchema.optional(),
+    invoiceDate: stringType().optional(),
+    dueDate: stringType().optional(),
+    taxAmount: AmountDecimalValidationError$inboundSchema.optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new CreateInvoiceError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  CreateInvoiceError$outboundSchema = instanceOfType(CreateInvoiceError).transform((v2) => v2.data$).pipe(objectType({
+    customerAccountID: stringType().optional(),
+    description: stringType().optional(),
+    lineItems: InvoiceLineItemsValidationError$outboundSchema.optional(),
+    invoiceDate: stringType().optional(),
+    dueDate: stringType().optional(),
+    taxAmount: AmountDecimalValidationError$outboundSchema.optional()
+  }));
+});
+
 // src/models/errors/createpaymentlinkerror.ts
 var CreatePaymentLinkError, CreatePaymentLinkError$inboundSchema, CreatePaymentLinkError$outboundSchema;
 var init_createpaymentlinkerror = __esm(() => {
@@ -49860,6 +50321,56 @@ var init_linkcarderror = __esm(() => {
   }));
 });
 
+// src/models/errors/listinvoicesvalidationerror.ts
+var ListInvoicesValidationError, ListInvoicesValidationError$inboundSchema, ListInvoicesValidationError$outboundSchema;
+var init_listinvoicesvalidationerror = __esm(() => {
+  init_esm();
+  init_mooverror();
+  ListInvoicesValidationError = class ListInvoicesValidationError extends MoovError {
+    status;
+    customerAccountID;
+    skip;
+    count;
+    data$;
+    constructor(err, httpMeta) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message, httpMeta);
+      this.data$ = err;
+      if (err.status != null)
+        this.status = err.status;
+      if (err.customerAccountID != null) {
+        this.customerAccountID = err.customerAccountID;
+      }
+      if (err.skip != null)
+        this.skip = err.skip;
+      if (err.count != null)
+        this.count = err.count;
+      this.name = "ListInvoicesValidationError";
+    }
+  };
+  ListInvoicesValidationError$inboundSchema = objectType({
+    status: stringType().optional(),
+    customerAccountID: stringType().optional(),
+    skip: stringType().optional(),
+    count: stringType().optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new ListInvoicesValidationError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  ListInvoicesValidationError$outboundSchema = instanceOfType(ListInvoicesValidationError).transform((v2) => v2.data$).pipe(objectType({
+    status: stringType().optional(),
+    customerAccountID: stringType().optional(),
+    skip: stringType().optional(),
+    count: stringType().optional()
+  }));
+});
+
 // src/models/errors/listtransfersvalidationerror.ts
 var ListTransfersValidationError, ListTransfersValidationError$inboundSchema, ListTransfersValidationError$outboundSchema;
 var init_listtransfersvalidationerror = __esm(() => {
@@ -50098,6 +50609,50 @@ var init_listwallettransactionsvalidationerror = __esm(() => {
   }));
 });
 
+// src/models/errors/markinvoicepaiderror.ts
+var MarkInvoicePaidError, MarkInvoicePaidError$inboundSchema, MarkInvoicePaidError$outboundSchema;
+var init_markinvoicepaiderror = __esm(() => {
+  init_esm();
+  init_mooverror();
+  MarkInvoicePaidError = class MarkInvoicePaidError extends MoovError {
+    foreignID;
+    description;
+    paymentDate;
+    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.foreignID != null)
+        this.foreignID = err.foreignID;
+      if (err.description != null)
+        this.description = err.description;
+      if (err.paymentDate != null)
+        this.paymentDate = err.paymentDate;
+      this.name = "MarkInvoicePaidError";
+    }
+  };
+  MarkInvoicePaidError$inboundSchema = objectType({
+    foreignID: stringType().optional(),
+    description: stringType().optional(),
+    paymentDate: stringType().optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new MarkInvoicePaidError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  MarkInvoicePaidError$outboundSchema = instanceOfType(MarkInvoicePaidError).transform((v2) => v2.data$).pipe(objectType({
+    foreignID: stringType().optional(),
+    description: stringType().optional(),
+    paymentDate: stringType().optional()
+  }));
+});
+
 // src/models/errors/microdepositvalidationerror.ts
 var MicroDepositValidationError, MicroDepositValidationError$inboundSchema, MicroDepositValidationError$outboundSchema;
 var init_microdepositvalidationerror = __esm(() => {
@@ -51157,6 +51712,66 @@ var init_updatecarderror = __esm(() => {
   }));
 });
 
+// src/models/errors/updateinvoiceerror.ts
+var UpdateInvoiceError, UpdateInvoiceError$inboundSchema, UpdateInvoiceError$outboundSchema;
+var init_updateinvoiceerror = __esm(() => {
+  init_esm();
+  init_components();
+  init_mooverror();
+  UpdateInvoiceError = class UpdateInvoiceError extends MoovError {
+    description;
+    lineItems;
+    invoiceDate;
+    dueDate;
+    status;
+    taxAmount;
+    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.description != null)
+        this.description = err.description;
+      if (err.lineItems != null)
+        this.lineItems = err.lineItems;
+      if (err.invoiceDate != null)
+        this.invoiceDate = err.invoiceDate;
+      if (err.dueDate != null)
+        this.dueDate = err.dueDate;
+      if (err.status != null)
+        this.status = err.status;
+      if (err.taxAmount != null)
+        this.taxAmount = err.taxAmount;
+      this.name = "UpdateInvoiceError";
+    }
+  };
+  UpdateInvoiceError$inboundSchema = objectType({
+    description: stringType().optional(),
+    lineItems: InvoiceLineItemsValidationError$inboundSchema.optional(),
+    invoiceDate: stringType().optional(),
+    dueDate: stringType().optional(),
+    status: stringType().optional(),
+    taxAmount: AmountDecimalValidationError$inboundSchema.optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new UpdateInvoiceError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  UpdateInvoiceError$outboundSchema = instanceOfType(UpdateInvoiceError).transform((v2) => v2.data$).pipe(objectType({
+    description: stringType().optional(),
+    lineItems: InvoiceLineItemsValidationError$outboundSchema.optional(),
+    invoiceDate: stringType().optional(),
+    dueDate: stringType().optional(),
+    status: stringType().optional(),
+    taxAmount: AmountDecimalValidationError$outboundSchema.optional()
+  }));
+});
+
 // src/models/errors/updateissuedcarderror.ts
 var UpdateIssuedCardError, UpdateIssuedCardError$inboundSchema, UpdateIssuedCardError$outboundSchema;
 var init_updateissuedcarderror = __esm(() => {
@@ -51465,6 +52080,7 @@ var init_errors2 = __esm(() => {
   init_brandvalidationerror();
   init_cardacquiringrefund2();
   init_createaccounterror();
+  init_createinvoiceerror();
   init_createpaymentlinkerror();
   init_createsweepconfigerror();
   init_createticketerror();
@@ -51478,9 +52094,11 @@ var init_errors2 = __esm(() => {
   init_imagerequestvalidationerror();
   init_linkapplepayerror();
   init_linkcarderror();
+  init_listinvoicesvalidationerror();
   init_listtransfersvalidationerror();
   init_listwalletsvalidationerror();
   init_listwallettransactionsvalidationerror();
+  init_markinvoicepaiderror();
   init_microdepositvalidationerror();
   init_mooverror();
   init_onboardinginviteerror();
@@ -51502,6 +52120,7 @@ var init_errors2 = __esm(() => {
   init_transferoptionsvalidationerror();
   init_transfervalidationerror();
   init_updatecarderror();
+  init_updateinvoiceerror();
   init_updateissuedcarderror();
   init_updatepaymentlinkerror();
   init_updateticketerror();
@@ -52068,6 +52687,62 @@ var init_createfeeplanagreements = __esm(() => {
   });
 });
 
+// src/models/operations/createinvoice.ts
+var CreateInvoiceGlobals$inboundSchema, CreateInvoiceGlobals$outboundSchema, CreateInvoiceRequest$inboundSchema, CreateInvoiceRequest$outboundSchema, CreateInvoiceResponse$inboundSchema, CreateInvoiceResponse$outboundSchema;
+var init_createinvoice2 = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  CreateInvoiceGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  CreateInvoiceGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  CreateInvoiceRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    CreateInvoice: CreateInvoice$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      CreateInvoice: "createInvoice"
+    });
+  });
+  CreateInvoiceRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    createInvoice: CreateInvoice$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      createInvoice: "CreateInvoice"
+    });
+  });
+  CreateInvoiceResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: Invoice$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  CreateInvoiceResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Invoice$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/createonboardinginvite.ts
 var CreateOnboardingInviteGlobals$inboundSchema, CreateOnboardingInviteGlobals$outboundSchema, CreateOnboardingInviteResponse$inboundSchema, CreateOnboardingInviteResponse$outboundSchema;
 var init_createonboardinginvite = __esm(() => {
@@ -54299,6 +54974,54 @@ var init_getimagemetadata = __esm(() => {
   });
 });
 
+// src/models/operations/getinvoice.ts
+var GetInvoiceGlobals$inboundSchema, GetInvoiceGlobals$outboundSchema, GetInvoiceRequest$inboundSchema, GetInvoiceRequest$outboundSchema, GetInvoiceResponse$inboundSchema, GetInvoiceResponse$outboundSchema;
+var init_getinvoice = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  GetInvoiceGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  GetInvoiceGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  GetInvoiceRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType()
+  });
+  GetInvoiceRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType()
+  });
+  GetInvoiceResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: Invoice$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  GetInvoiceResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Invoice$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/getissuedcard.ts
 var GetIssuedCardGlobals$inboundSchema, GetIssuedCardGlobals$outboundSchema, GetIssuedCardRequest$inboundSchema, GetIssuedCardRequest$outboundSchema, GetIssuedCardResponse$inboundSchema, GetIssuedCardResponse$outboundSchema;
 var init_getissuedcard = __esm(() => {
@@ -56814,6 +57537,60 @@ var init_listinstitutions = __esm(() => {
   });
 });
 
+// src/models/operations/listinvoices.ts
+var ListInvoicesGlobals$inboundSchema, ListInvoicesGlobals$outboundSchema, ListInvoicesRequest$inboundSchema, ListInvoicesRequest$outboundSchema, ListInvoicesResponse$inboundSchema, ListInvoicesResponse$outboundSchema;
+var init_listinvoices = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ListInvoicesGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  ListInvoicesGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  ListInvoicesRequest$inboundSchema = objectType({
+    skip: numberType().int().optional(),
+    count: numberType().int().optional(),
+    status: InvoiceStatus$inboundSchema.optional(),
+    customerAccountID: stringType().optional(),
+    accountID: stringType()
+  });
+  ListInvoicesRequest$outboundSchema = objectType({
+    skip: numberType().int().optional(),
+    count: numberType().int().optional(),
+    status: InvoiceStatus$outboundSchema.optional(),
+    customerAccountID: stringType().optional(),
+    accountID: stringType()
+  });
+  ListInvoicesResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: arrayType(Invoice$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ListInvoicesResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: arrayType(Invoice$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/listissuedcardauthorizationevents.ts
 var ListIssuedCardAuthorizationEventsGlobals$inboundSchema, ListIssuedCardAuthorizationEventsGlobals$outboundSchema, ListIssuedCardAuthorizationEventsRequest$inboundSchema, ListIssuedCardAuthorizationEventsRequest$outboundSchema, ListIssuedCardAuthorizationEventsResponse$inboundSchema, ListIssuedCardAuthorizationEventsResponse$outboundSchema;
 var init_listissuedcardauthorizationevents = __esm(() => {
@@ -58141,6 +58918,64 @@ var init_listwallettransactions = __esm(() => {
   });
 });
 
+// src/models/operations/markpaidinvoice.ts
+var MarkPaidInvoiceGlobals$inboundSchema, MarkPaidInvoiceGlobals$outboundSchema, MarkPaidInvoiceRequest$inboundSchema, MarkPaidInvoiceRequest$outboundSchema, MarkPaidInvoiceResponse$inboundSchema, MarkPaidInvoiceResponse$outboundSchema;
+var init_markpaidinvoice = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  MarkPaidInvoiceGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  MarkPaidInvoiceGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  MarkPaidInvoiceRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType(),
+    MarkInvoicePaid: MarkInvoicePaid$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      MarkInvoicePaid: "markInvoicePaid"
+    });
+  });
+  MarkPaidInvoiceRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType(),
+    markInvoicePaid: MarkInvoicePaid$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      markInvoicePaid: "MarkInvoicePaid"
+    });
+  });
+  MarkPaidInvoiceResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: Invoice$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  MarkPaidInvoiceResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Invoice$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/ping.ts
 var PingGlobals$inboundSchema, PingGlobals$outboundSchema, PingRequest$inboundSchema, PingRequest$outboundSchema, PingResponse$inboundSchema, PingResponse$outboundSchema;
 var init_ping = __esm(() => {
@@ -59067,6 +59902,64 @@ var init_updateimagemetadata = __esm(() => {
   });
 });
 
+// src/models/operations/updateinvoice.ts
+var UpdateInvoiceGlobals$inboundSchema, UpdateInvoiceGlobals$outboundSchema, UpdateInvoiceRequest$inboundSchema, UpdateInvoiceRequest$outboundSchema, UpdateInvoiceResponse$inboundSchema, UpdateInvoiceResponse$outboundSchema;
+var init_updateinvoice2 = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  UpdateInvoiceGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  UpdateInvoiceGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  UpdateInvoiceRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType(),
+    UpdateInvoice: UpdateInvoice$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      UpdateInvoice: "updateInvoice"
+    });
+  });
+  UpdateInvoiceRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    invoiceID: stringType(),
+    updateInvoice: UpdateInvoice$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      updateInvoice: "UpdateInvoice"
+    });
+  });
+  UpdateInvoiceResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: Invoice$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  UpdateInvoiceResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Invoice$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/updateissuedcard.ts
 var UpdateIssuedCardGlobals$inboundSchema, UpdateIssuedCardGlobals$outboundSchema, UpdateIssuedCardRequest$inboundSchema, UpdateIssuedCardRequest$outboundSchema, UpdateIssuedCardResponse$inboundSchema, UpdateIssuedCardResponse$outboundSchema;
 var init_updateissuedcard2 = __esm(() => {
@@ -59938,6 +60831,7 @@ var init_operations = __esm(() => {
   init_createbrand();
   init_createcancellation();
   init_createfeeplanagreements();
+  init_createinvoice2();
   init_createonboardinginvite();
   init_createpaymentlink2();
   init_createproduct();
@@ -59983,6 +60877,7 @@ var init_operations = __esm(() => {
   init_getfiledetails();
   init_getfullissuedcard();
   init_getimagemetadata();
+  init_getinvoice();
   init_getissuedcard();
   init_getissuedcardauthorization();
   init_getissuedcardtransaction();
@@ -60032,6 +60927,7 @@ var init_operations = __esm(() => {
   init_listimagemetadata();
   init_listindustries();
   init_listinstitutions();
+  init_listinvoices();
   init_listissuedcardauthorizationevents();
   init_listissuedcardauthorizations();
   init_listissuedcards();
@@ -60057,6 +60953,7 @@ var init_operations = __esm(() => {
   init_listtransfers();
   init_listwallets();
   init_listwallettransactions();
+  init_markpaidinvoice();
   init_ping();
   init_registerapplepaymerchantdomains2();
   init_requestcapabilities();
@@ -60075,6 +60972,7 @@ var init_operations = __esm(() => {
   init_updatedisputeevidence();
   init_updateimage();
   init_updateimagemetadata();
+  init_updateinvoice2();
   init_updateissuedcard2();
   init_updatepaymentlink2();
   init_updateproduct();
@@ -70976,26 +71874,26 @@ you'll need to specify the \`/institutions.read\` scope.`,
   };
 });
 
-// src/funcs/issuingTransactionsGet.ts
-function issuingTransactionsGet(client, request, options) {
+// src/funcs/invoicesCreateInvoice.ts
+function invoicesCreateInvoice(client, request, options) {
   return new APIPromise($do90(client, request, options));
 }
 async function $do90(client, request, options) {
-  const parsed = safeParse(request, (value) => GetIssuedCardTransactionRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => CreateInvoiceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = encodeJSON("body", payload.CreateInvoice, { explode: true });
   const pathParams = {
     accountID: encodeSimple("accountID", payload.accountID, {
       explode: false,
       charEncoding: "percent"
-    }),
-    cardTransactionID: encodeSimple("cardTransactionID", payload.cardTransactionID, { explode: false, charEncoding: "percent" })
+    })
   };
-  const path = pathToFunc("/issuing/{accountID}/card-transactions/{cardTransactionID}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/invoices")(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" })
   }));
@@ -71004,7 +71902,7 @@ async function $do90(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getIssuedCardTransaction",
+    operationID: "createInvoice",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -71013,7 +71911,7 @@ async function $do90(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -71027,7 +71925,19 @@ async function $do90(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["401", "403", "404", "429", "4XX", "500", "504", "5XX"],
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -71038,44 +71948,45 @@ async function $do90(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, GetIssuedCardTransactionResponse$inboundSchema, {
+  const [result] = await match(json(201, CreateInvoiceResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
-  }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, CreateInvoiceError$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_issuingTransactionsGet = __esm(() => {
+var init_invoicesCreateInvoice = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
+  init_errors2();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/issuingTransactionsGet.ts
-var args90, tool$issuingTransactionsGet;
-var init_issuingTransactionsGet2 = __esm(() => {
-  init_issuingTransactionsGet();
+// src/mcp-server/tools/invoicesCreateInvoice.ts
+var args90, tool$invoicesCreateInvoice;
+var init_invoicesCreateInvoice2 = __esm(() => {
+  init_invoicesCreateInvoice();
   init_operations();
   init_tools();
   args90 = {
-    request: GetIssuedCardTransactionRequest$inboundSchema
+    request: CreateInvoiceRequest$inboundSchema
   };
-  tool$issuingTransactionsGet = {
-    name: "issuing-transactions-get",
-    description: `Retrieves details of an issued card transaction associated with a specific Moov account.
+  tool$invoicesCreateInvoice = {
+    name: "invoices-create-invoice",
+    description: `Create an invoice for a Moov account.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
+you'll need to specify the \`/accounts/{accountID}/invoices.write\` scope.`,
     args: args90,
     tool: async (client, args91, ctx) => {
-      const [result, apiCall] = await issuingTransactionsGet(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await invoicesCreateInvoice(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71088,12 +71999,12 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
   };
 });
 
-// src/funcs/issuingTransactionsGetAuthorization.ts
-function issuingTransactionsGetAuthorization(client, request, options) {
+// src/funcs/invoicesGetInvoice.ts
+function invoicesGetInvoice(client, request, options) {
   return new APIPromise($do91(client, request, options));
 }
 async function $do91(client, request, options) {
-  const parsed = safeParse(request, (value) => GetIssuedCardAuthorizationRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => GetInvoiceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -71104,12 +72015,12 @@ async function $do91(client, request, options) {
       explode: false,
       charEncoding: "percent"
     }),
-    authorizationID: encodeSimple("authorizationID", payload.authorizationID, {
+    invoiceID: encodeSimple("invoiceID", payload.invoiceID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/issuing/{accountID}/authorizations/{authorizationID}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/invoices/{invoiceID}")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "X-Moov-Version": encodeSimple("X-Moov-Version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
@@ -71119,7 +72030,614 @@ async function $do91(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getIssuedCardAuthorization",
+    operationID: "getInvoice",
+    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, GetInvoiceResponse$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_invoicesGetInvoice = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/invoicesGetInvoice.ts
+var args91, tool$invoicesGetInvoice;
+var init_invoicesGetInvoice2 = __esm(() => {
+  init_invoicesGetInvoice();
+  init_operations();
+  init_tools();
+  args91 = {
+    request: GetInvoiceRequest$inboundSchema
+  };
+  tool$invoicesGetInvoice = {
+    name: "invoices-get-invoice",
+    description: `Retrieve an invoice by ID.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/invoices.read\` scope.`,
+    args: args91,
+    tool: async (client, args92, ctx) => {
+      const [result, apiCall] = await invoicesGetInvoice(client, args92.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/invoicesListInvoices.ts
+function invoicesListInvoices(client, request, options) {
+  return new APIPromise($do92(client, request, options));
+}
+async function $do92(client, request, options) {
+  const parsed = safeParse(request, (value) => ListInvoicesRequest$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}/invoices")(pathParams);
+  const query = encodeFormQuery({
+    count: payload.count,
+    customerAccountID: payload.customerAccountID,
+    skip: payload.skip,
+    status: payload.status
+  }, { 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: "listInvoices",
+    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", "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, ListInvoicesResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr(422, ListInvoicesValidationError$inboundSchema, {
+    hdrs: true
+  }), 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_invoicesListInvoices = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/invoicesListInvoices.ts
+var args92, tool$invoicesListInvoices;
+var init_invoicesListInvoices2 = __esm(() => {
+  init_invoicesListInvoices();
+  init_operations();
+  init_tools();
+  args92 = {
+    request: ListInvoicesRequest$inboundSchema
+  };
+  tool$invoicesListInvoices = {
+    name: "invoices-list-invoices",
+    description: `List all the invoices created under a Moov account.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/invoices.read\` scope.`,
+    args: args92,
+    tool: async (client, args93, ctx) => {
+      const [result, apiCall] = await invoicesListInvoices(client, args93.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/invoicesMarkPaidInvoice.ts
+function invoicesMarkPaidInvoice(client, request, options) {
+  return new APIPromise($do93(client, request, options));
+}
+async function $do93(client, request, options) {
+  const parsed = safeParse(request, (value) => MarkPaidInvoiceRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.MarkInvoicePaid, { explode: true });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    invoiceID: encodeSimple("invoiceID", payload.invoiceID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/invoices/{invoiceID}/mark-paid")(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: "markPaidInvoice",
+    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, MarkPaidInvoiceResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, MarkInvoicePaidError$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_invoicesMarkPaidInvoice = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/invoicesMarkPaidInvoice.ts
+var args93, tool$invoicesMarkPaidInvoice;
+var init_invoicesMarkPaidInvoice2 = __esm(() => {
+  init_invoicesMarkPaidInvoice();
+  init_operations();
+  init_tools();
+  args93 = {
+    request: MarkPaidInvoiceRequest$inboundSchema
+  };
+  tool$invoicesMarkPaidInvoice = {
+    name: "invoices-mark-paid-invoice",
+    description: `Marks an invoice as paid outside of the Moov platform.
+If a payment link was created, the corresponding payment link is canceled, but a receipt is still sent.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/invoices.write\` scope.`,
+    args: args93,
+    tool: async (client, args94, ctx) => {
+      const [result, apiCall] = await invoicesMarkPaidInvoice(client, args94.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/invoicesUpdateInvoice.ts
+function invoicesUpdateInvoice(client, request, options) {
+  return new APIPromise($do94(client, request, options));
+}
+async function $do94(client, request, options) {
+  const parsed = safeParse(request, (value) => UpdateInvoiceRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.UpdateInvoice, { explode: true });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    invoiceID: encodeSimple("invoiceID", payload.invoiceID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/invoices/{invoiceID}")(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: "updateInvoice",
+    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: "PATCH",
+    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, UpdateInvoiceResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, UpdateInvoiceError$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_invoicesUpdateInvoice = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/invoicesUpdateInvoice.ts
+var args94, tool$invoicesUpdateInvoice;
+var init_invoicesUpdateInvoice2 = __esm(() => {
+  init_invoicesUpdateInvoice();
+  init_operations();
+  init_tools();
+  args94 = {
+    request: UpdateInvoiceRequest$inboundSchema
+  };
+  tool$invoicesUpdateInvoice = {
+    name: "invoices-update-invoice",
+    description: `Updates an invoice.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/invoices.write\` scope.`,
+    args: args94,
+    tool: async (client, args95, ctx) => {
+      const [result, apiCall] = await invoicesUpdateInvoice(client, args95.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/issuingTransactionsGet.ts
+function issuingTransactionsGet(client, request, options) {
+  return new APIPromise($do95(client, request, options));
+}
+async function $do95(client, request, options) {
+  const parsed = safeParse(request, (value) => GetIssuedCardTransactionRequest$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"
+    }),
+    cardTransactionID: encodeSimple("cardTransactionID", payload.cardTransactionID, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/issuing/{accountID}/card-transactions/{cardTransactionID}")(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: "getIssuedCardTransaction",
+    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, GetIssuedCardTransactionResponse$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_issuingTransactionsGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/issuingTransactionsGet.ts
+var args95, tool$issuingTransactionsGet;
+var init_issuingTransactionsGet2 = __esm(() => {
+  init_issuingTransactionsGet();
+  init_operations();
+  init_tools();
+  args95 = {
+    request: GetIssuedCardTransactionRequest$inboundSchema
+  };
+  tool$issuingTransactionsGet = {
+    name: "issuing-transactions-get",
+    description: `Retrieves details of an issued card transaction associated with a specific Moov account.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
+you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
+    args: args95,
+    tool: async (client, args96, ctx) => {
+      const [result, apiCall] = await issuingTransactionsGet(client, args96.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/issuingTransactionsGetAuthorization.ts
+function issuingTransactionsGetAuthorization(client, request, options) {
+  return new APIPromise($do96(client, request, options));
+}
+async function $do96(client, request, options) {
+  const parsed = safeParse(request, (value) => GetIssuedCardAuthorizationRequest$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"
+    }),
+    authorizationID: encodeSimple("authorizationID", payload.authorizationID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/issuing/{accountID}/authorizations/{authorizationID}")(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: "getIssuedCardAuthorization",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -71174,12 +72692,12 @@ var init_issuingTransactionsGetAuthorization = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsGetAuthorization.ts
-var args91, tool$issuingTransactionsGetAuthorization;
+var args96, tool$issuingTransactionsGetAuthorization;
 var init_issuingTransactionsGetAuthorization2 = __esm(() => {
   init_issuingTransactionsGetAuthorization();
   init_operations();
   init_tools();
-  args91 = {
+  args96 = {
     request: GetIssuedCardAuthorizationRequest$inboundSchema
   };
   tool$issuingTransactionsGetAuthorization = {
@@ -71188,9 +72706,9 @@ var init_issuingTransactionsGetAuthorization2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
-    args: args91,
-    tool: async (client, args92, ctx) => {
-      const [result, apiCall] = await issuingTransactionsGetAuthorization(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args96,
+    tool: async (client, args97, ctx) => {
+      const [result, apiCall] = await issuingTransactionsGetAuthorization(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71205,9 +72723,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/issuingTransactionsList.ts
 function issuingTransactionsList(client, request, options) {
-  return new APIPromise($do92(client, request, options));
+  return new APIPromise($do97(client, request, options));
 }
-async function $do92(client, request, options) {
+async function $do97(client, request, options) {
   const parsed = safeParse(request, (value) => ListIssuedCardTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71293,12 +72811,12 @@ var init_issuingTransactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsList.ts
-var args92, tool$issuingTransactionsList;
+var args97, tool$issuingTransactionsList;
 var init_issuingTransactionsList2 = __esm(() => {
   init_issuingTransactionsList();
   init_operations();
   init_tools();
-  args92 = {
+  args97 = {
     request: ListIssuedCardTransactionsRequest$inboundSchema
   };
   tool$issuingTransactionsList = {
@@ -71307,9 +72825,9 @@ var init_issuingTransactionsList2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
-    args: args92,
-    tool: async (client, args93, ctx) => {
-      const [result, apiCall] = await issuingTransactionsList(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args97,
+    tool: async (client, args98, ctx) => {
+      const [result, apiCall] = await issuingTransactionsList(client, args98.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71324,9 +72842,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/issuingTransactionsListAuthorizationEvents.ts
 function issuingTransactionsListAuthorizationEvents(client, request, options) {
-  return new APIPromise($do93(client, request, options));
+  return new APIPromise($do98(client, request, options));
 }
-async function $do93(client, request, options) {
+async function $do98(client, request, options) {
   const parsed = safeParse(request, (value) => ListIssuedCardAuthorizationEventsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71410,12 +72928,12 @@ var init_issuingTransactionsListAuthorizationEvents = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsListAuthorizationEvents.ts
-var args93, tool$issuingTransactionsListAuthorizationEvents;
+var args98, tool$issuingTransactionsListAuthorizationEvents;
 var init_issuingTransactionsListAuthorizationEvents2 = __esm(() => {
   init_issuingTransactionsListAuthorizationEvents();
   init_operations();
   init_tools();
-  args93 = {
+  args98 = {
     request: ListIssuedCardAuthorizationEventsRequest$inboundSchema
   };
   tool$issuingTransactionsListAuthorizationEvents = {
@@ -71424,9 +72942,9 @@ var init_issuingTransactionsListAuthorizationEvents2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
-    args: args93,
-    tool: async (client, args94, ctx) => {
-      const [result, apiCall] = await issuingTransactionsListAuthorizationEvents(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args98,
+    tool: async (client, args99, ctx) => {
+      const [result, apiCall] = await issuingTransactionsListAuthorizationEvents(client, args99.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71441,9 +72959,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/issuingTransactionsListAuthorizations.ts
 function issuingTransactionsListAuthorizations(client, request, options) {
-  return new APIPromise($do94(client, request, options));
+  return new APIPromise($do99(client, request, options));
 }
-async function $do94(client, request, options) {
+async function $do99(client, request, options) {
   const parsed = safeParse(request, (value) => ListIssuedCardAuthorizationsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71530,12 +73048,12 @@ var init_issuingTransactionsListAuthorizations = __esm(() => {
 });
 
 // src/mcp-server/tools/issuingTransactionsListAuthorizations.ts
-var args94, tool$issuingTransactionsListAuthorizations;
+var args99, tool$issuingTransactionsListAuthorizations;
 var init_issuingTransactionsListAuthorizations2 = __esm(() => {
   init_issuingTransactionsListAuthorizations();
   init_operations();
   init_tools();
-  args94 = {
+  args99 = {
     request: ListIssuedCardAuthorizationsRequest$inboundSchema
   };
   tool$issuingTransactionsListAuthorizations = {
@@ -71544,9 +73062,9 @@ var init_issuingTransactionsListAuthorizations2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
-    args: args94,
-    tool: async (client, args95, ctx) => {
-      const [result, apiCall] = await issuingTransactionsListAuthorizations(client, args95.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args99,
+    tool: async (client, args100, ctx) => {
+      const [result, apiCall] = await issuingTransactionsListAuthorizations(client, args100.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71561,9 +73079,9 @@ you'll need to specify the \`/accounts/{accountID}/issued-cards.read\` scope.`,
 
 // src/funcs/onboardingCreateInvite.ts
 function onboardingCreateInvite(client, request, options) {
-  return new APIPromise($do95(client, request, options));
+  return new APIPromise($do100(client, request, options));
 }
-async function $do95(client, request, options) {
+async function $do100(client, request, options) {
   const parsed = safeParse(request, (value) => OnboardingInviteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71650,12 +73168,12 @@ var init_onboardingCreateInvite = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingCreateInvite.ts
-var args95, tool$onboardingCreateInvite;
+var args100, tool$onboardingCreateInvite;
 var init_onboardingCreateInvite2 = __esm(() => {
   init_onboardingCreateInvite();
   init_components();
   init_tools();
-  args95 = {
+  args100 = {
     request: OnboardingInviteRequest$inboundSchema
   };
   tool$onboardingCreateInvite = {
@@ -71664,9 +73182,9 @@ var init_onboardingCreateInvite2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts.write\` scope.`,
-    args: args95,
-    tool: async (client, args96, ctx) => {
-      const [result, apiCall] = await onboardingCreateInvite(client, args96.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args100,
+    tool: async (client, args101, ctx) => {
+      const [result, apiCall] = await onboardingCreateInvite(client, args101.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71681,9 +73199,9 @@ you'll need to specify the \`/accounts.write\` scope.`,
 
 // src/funcs/onboardingGetInvite.ts
 function onboardingGetInvite(client, request, options) {
-  return new APIPromise($do96(client, request, options));
+  return new APIPromise($do101(client, request, options));
 }
-async function $do96(client, request, options) {
+async function $do101(client, request, options) {
   const parsed = safeParse(request, (value) => GetOnboardingInviteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71761,12 +73279,12 @@ var init_onboardingGetInvite = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingGetInvite.ts
-var args96, tool$onboardingGetInvite;
+var args101, tool$onboardingGetInvite;
 var init_onboardingGetInvite2 = __esm(() => {
   init_onboardingGetInvite();
   init_operations();
   init_tools();
-  args96 = {
+  args101 = {
     request: GetOnboardingInviteRequest$inboundSchema
   };
   tool$onboardingGetInvite = {
@@ -71775,9 +73293,9 @@ var init_onboardingGetInvite2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts.read\` scope.`,
-    args: args96,
-    tool: async (client, args97, ctx) => {
-      const [result, apiCall] = await onboardingGetInvite(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args101,
+    tool: async (client, args102, ctx) => {
+      const [result, apiCall] = await onboardingGetInvite(client, args102.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71792,9 +73310,9 @@ you'll need to specify the \`/accounts.read\` scope.`,
 
 // src/funcs/onboardingListInvites.ts
 function onboardingListInvites(client, _request, options) {
-  return new APIPromise($do97(client, _request, options));
+  return new APIPromise($do102(client, _request, options));
 }
-async function $do97(client, _request, options) {
+async function $do102(client, _request, options) {
   const path = pathToFunc("/onboarding-invites")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -71858,12 +73376,12 @@ var init_onboardingListInvites = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingListInvites.ts
-var args97, tool$onboardingListInvites;
+var args102, tool$onboardingListInvites;
 var init_onboardingListInvites2 = __esm(() => {
   init_onboardingListInvites();
   init_operations();
   init_tools();
-  args97 = {
+  args102 = {
     request: ListOnboardingInvitesRequest$inboundSchema
   };
   tool$onboardingListInvites = {
@@ -71872,9 +73390,9 @@ var init_onboardingListInvites2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts.read\` scope.`,
-    args: args97,
-    tool: async (client, args98, ctx) => {
-      const [result, apiCall] = await onboardingListInvites(client, args98.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args102,
+    tool: async (client, args103, ctx) => {
+      const [result, apiCall] = await onboardingListInvites(client, args103.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71889,9 +73407,9 @@ you'll need to specify the \`/accounts.read\` scope.`,
 
 // src/funcs/onboardingRevokeInvite.ts
 function onboardingRevokeInvite(client, request, options) {
-  return new APIPromise($do98(client, request, options));
+  return new APIPromise($do103(client, request, options));
 }
-async function $do98(client, request, options) {
+async function $do103(client, request, options) {
   const parsed = safeParse(request, (value) => RevokeOnboardingInviteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71966,12 +73484,12 @@ var init_onboardingRevokeInvite = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingRevokeInvite.ts
-var args98, tool$onboardingRevokeInvite;
+var args103, tool$onboardingRevokeInvite;
 var init_onboardingRevokeInvite2 = __esm(() => {
   init_onboardingRevokeInvite();
   init_operations();
   init_tools();
-  args98 = {
+  args103 = {
     request: RevokeOnboardingInviteRequest$inboundSchema
   };
   tool$onboardingRevokeInvite = {
@@ -71980,9 +73498,9 @@ var init_onboardingRevokeInvite2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts.write\` scope.`,
-    args: args98,
-    tool: async (client, args99, ctx) => {
-      const [result, apiCall] = await onboardingRevokeInvite(client, args99.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args103,
+    tool: async (client, args104, ctx) => {
+      const [result, apiCall] = await onboardingRevokeInvite(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71996,9 +73514,9 @@ you'll need to specify the \`/accounts.write\` scope.`,
 
 // src/funcs/paymentLinksCreate.ts
 function paymentLinksCreate(client, request, options) {
-  return new APIPromise($do99(client, request, options));
+  return new APIPromise($do104(client, request, options));
 }
-async function $do99(client, request, options) {
+async function $do104(client, request, options) {
   const parsed = safeParse(request, (value) => CreatePaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72090,12 +73608,12 @@ var init_paymentLinksCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksCreate.ts
-var args99, tool$paymentLinksCreate;
+var args104, tool$paymentLinksCreate;
 var init_paymentLinksCreate2 = __esm(() => {
   init_paymentLinksCreate();
   init_operations();
   init_tools();
-  args99 = {
+  args104 = {
     request: CreatePaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksCreate = {
@@ -72104,9 +73622,9 @@ var init_paymentLinksCreate2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args99,
-    tool: async (client, args100, ctx) => {
-      const [result, apiCall] = await paymentLinksCreate(client, args100.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args104,
+    tool: async (client, args105, ctx) => {
+      const [result, apiCall] = await paymentLinksCreate(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72121,9 +73639,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/paymentLinksDisable.ts
 function paymentLinksDisable(client, request, options) {
-  return new APIPromise($do100(client, request, options));
+  return new APIPromise($do105(client, request, options));
 }
-async function $do100(client, request, options) {
+async function $do105(client, request, options) {
   const parsed = safeParse(request, (value) => DisablePaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72204,12 +73722,12 @@ var init_paymentLinksDisable = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksDisable.ts
-var args100, tool$paymentLinksDisable;
+var args105, tool$paymentLinksDisable;
 var init_paymentLinksDisable2 = __esm(() => {
   init_paymentLinksDisable();
   init_operations();
   init_tools();
-  args100 = {
+  args105 = {
     request: DisablePaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksDisable = {
@@ -72218,9 +73736,9 @@ var init_paymentLinksDisable2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args100,
-    tool: async (client, args101, ctx) => {
-      const [result, apiCall] = await paymentLinksDisable(client, args101.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args105,
+    tool: async (client, args106, ctx) => {
+      const [result, apiCall] = await paymentLinksDisable(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72234,9 +73752,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/paymentLinksGet.ts
 function paymentLinksGet(client, request, options) {
-  return new APIPromise($do101(client, request, options));
+  return new APIPromise($do106(client, request, options));
 }
-async function $do101(client, request, options) {
+async function $do106(client, request, options) {
   const parsed = safeParse(request, (value) => GetPaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72318,12 +73836,12 @@ var init_paymentLinksGet = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksGet.ts
-var args101, tool$paymentLinksGet;
+var args106, tool$paymentLinksGet;
 var init_paymentLinksGet2 = __esm(() => {
   init_paymentLinksGet();
   init_operations();
   init_tools();
-  args101 = {
+  args106 = {
     request: GetPaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksGet = {
@@ -72332,9 +73850,9 @@ var init_paymentLinksGet2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args101,
-    tool: async (client, args102, ctx) => {
-      const [result, apiCall] = await paymentLinksGet(client, args102.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args106,
+    tool: async (client, args107, ctx) => {
+      const [result, apiCall] = await paymentLinksGet(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72349,9 +73867,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/paymentLinksGetQRCode.ts
 function paymentLinksGetQRCode(client, request, options) {
-  return new APIPromise($do102(client, request, options));
+  return new APIPromise($do107(client, request, options));
 }
-async function $do102(client, request, options) {
+async function $do107(client, request, options) {
   const parsed = safeParse(request, (value) => GetPaymentLinkQRCodeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72437,12 +73955,12 @@ var init_paymentLinksGetQRCode = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksGetQRCode.ts
-var args102, tool$paymentLinksGetQRCode;
+var args107, tool$paymentLinksGetQRCode;
 var init_paymentLinksGetQRCode2 = __esm(() => {
   init_paymentLinksGetQRCode();
   init_operations();
   init_tools();
-  args102 = {
+  args107 = {
     request: GetPaymentLinkQRCodeRequest$inboundSchema
   };
   tool$paymentLinksGetQRCode = {
@@ -72453,9 +73971,9 @@ Use the \`Accept\` header to specify the format of the response. Supported forma
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args102,
-    tool: async (client, args103, ctx) => {
-      const [result, apiCall] = await paymentLinksGetQRCode(client, args103.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args107,
+    tool: async (client, args108, ctx) => {
+      const [result, apiCall] = await paymentLinksGetQRCode(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72470,9 +73988,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/paymentLinksList.ts
 function paymentLinksList(client, request, options) {
-  return new APIPromise($do103(client, request, options));
+  return new APIPromise($do108(client, request, options));
 }
-async function $do103(client, request, options) {
+async function $do108(client, request, options) {
   const parsed = safeParse(request, (value) => ListPaymentLinksRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72557,12 +74075,12 @@ var init_paymentLinksList = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksList.ts
-var args103, tool$paymentLinksList;
+var args108, tool$paymentLinksList;
 var init_paymentLinksList2 = __esm(() => {
   init_paymentLinksList();
   init_operations();
   init_tools();
-  args103 = {
+  args108 = {
     request: ListPaymentLinksRequest$inboundSchema
   };
   tool$paymentLinksList = {
@@ -72571,9 +74089,9 @@ var init_paymentLinksList2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args103,
-    tool: async (client, args104, ctx) => {
-      const [result, apiCall] = await paymentLinksList(client, args104.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args108,
+    tool: async (client, args109, ctx) => {
+      const [result, apiCall] = await paymentLinksList(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72588,9 +74106,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/paymentLinksUpdate.ts
 function paymentLinksUpdate(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) => UpdatePaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72686,12 +74204,12 @@ var init_paymentLinksUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksUpdate.ts
-var args104, tool$paymentLinksUpdate;
+var args109, tool$paymentLinksUpdate;
 var init_paymentLinksUpdate2 = __esm(() => {
   init_paymentLinksUpdate();
   init_operations();
   init_tools();
-  args104 = {
+  args109 = {
     request: UpdatePaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksUpdate = {
@@ -72700,9 +74218,9 @@ var init_paymentLinksUpdate2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args104,
-    tool: async (client, args105, ctx) => {
-      const [result, apiCall] = await paymentLinksUpdate(client, args105.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args109,
+    tool: async (client, args110, ctx) => {
+      const [result, apiCall] = await paymentLinksUpdate(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72717,9 +74235,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/paymentMethodsGet.ts
 function paymentMethodsGet(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) => GetPaymentMethodRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72801,12 +74319,12 @@ var init_paymentMethodsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentMethodsGet.ts
-var args105, tool$paymentMethodsGet;
+var args110, tool$paymentMethodsGet;
 var init_paymentMethodsGet2 = __esm(() => {
   init_paymentMethodsGet();
   init_operations();
   init_tools();
-  args105 = {
+  args110 = {
     request: GetPaymentMethodRequest$inboundSchema
   };
   tool$paymentMethodsGet = {
@@ -72815,9 +74333,9 @@ var init_paymentMethodsGet2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/payment-methods.read\` scope.`,
-    args: args105,
-    tool: async (client, args106, ctx) => {
-      const [result, apiCall] = await paymentMethodsGet(client, args106.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args110,
+    tool: async (client, args111, ctx) => {
+      const [result, apiCall] = await paymentMethodsGet(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72832,9 +74350,9 @@ you'll need to specify the \`/accounts/{accountID}/payment-methods.read\` scope.
 
 // src/funcs/paymentMethodsList.ts
 function paymentMethodsList(client, request, options) {
-  return new APIPromise($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) => ListPaymentMethodsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72917,12 +74435,12 @@ var init_paymentMethodsList = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentMethodsList.ts
-var args106, tool$paymentMethodsList;
+var args111, tool$paymentMethodsList;
 var init_paymentMethodsList2 = __esm(() => {
   init_paymentMethodsList();
   init_operations();
   init_tools();
-  args106 = {
+  args111 = {
     request: ListPaymentMethodsRequest$inboundSchema
   };
   tool$paymentMethodsList = {
@@ -72932,9 +74450,9 @@ guide](https://docs.moov.io/guides/money-movement/payment-methods/) to learn mor
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/payment-methods.read\` scope.`,
-    args: args106,
-    tool: async (client, args107, ctx) => {
-      const [result, apiCall] = await paymentMethodsList(client, args107.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args111,
+    tool: async (client, args112, ctx) => {
+      const [result, apiCall] = await paymentMethodsList(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72949,9 +74467,9 @@ you'll need to specify the \`/accounts/{accountID}/payment-methods.read\` scope.
 
 // src/funcs/pingPing.ts
 function pingPing(client, _request, options) {
-  return new APIPromise($do107(client, _request, options));
+  return new APIPromise($do112(client, _request, options));
 }
-async function $do107(client, _request, options) {
+async function $do112(client, _request, options) {
   const path = pathToFunc("/ping")();
   const headers = new Headers(compactMap({
     Accept: "*/*",
@@ -73014,12 +74532,12 @@ var init_pingPing = __esm(() => {
 });
 
 // src/mcp-server/tools/pingPing.ts
-var args107, tool$pingPing;
+var args112, tool$pingPing;
 var init_pingPing2 = __esm(() => {
   init_pingPing();
   init_operations();
   init_tools();
-  args107 = {
+  args112 = {
     request: PingRequest$inboundSchema
   };
   tool$pingPing = {
@@ -73028,9 +74546,9 @@ var init_pingPing2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/ping.read\` scope.`,
-    args: args107,
-    tool: async (client, args108, ctx) => {
-      const [result, apiCall] = await pingPing(client, args108.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args112,
+    tool: async (client, args113, ctx) => {
+      const [result, apiCall] = await pingPing(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73044,9 +74562,9 @@ you'll need to specify the \`/ping.read\` scope.`,
 
 // src/funcs/productsCreate.ts
 function productsCreate(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) => CreateProductRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73140,20 +74658,20 @@ var init_productsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/productsCreate.ts
-var args108, tool$productsCreate;
+var args113, tool$productsCreate;
 var init_productsCreate2 = __esm(() => {
   init_productsCreate();
   init_operations();
   init_tools();
-  args108 = {
+  args113 = {
     request: CreateProductRequest$inboundSchema
   };
   tool$productsCreate = {
     name: "products-create",
     description: `Creates a new product for the specified account.`,
-    args: args108,
-    tool: async (client, args109, ctx) => {
-      const [result, apiCall] = await productsCreate(client, args109.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args113,
+    tool: async (client, args114, ctx) => {
+      const [result, apiCall] = await productsCreate(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73168,9 +74686,9 @@ var init_productsCreate2 = __esm(() => {
 
 // src/funcs/productsDisable.ts
 function productsDisable(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) => DisableProductRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73263,12 +74781,12 @@ var init_productsDisable = __esm(() => {
 });
 
 // src/mcp-server/tools/productsDisable.ts
-var args109, tool$productsDisable;
+var args114, tool$productsDisable;
 var init_productsDisable2 = __esm(() => {
   init_productsDisable();
   init_operations();
   init_tools();
-  args109 = {
+  args114 = {
     request: DisableProductRequest$inboundSchema
   };
   tool$productsDisable = {
@@ -73276,9 +74794,9 @@ var init_productsDisable2 = __esm(() => {
     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: args109,
-    tool: async (client, args110, ctx) => {
-      const [result, apiCall] = await productsDisable(client, args110.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args114,
+    tool: async (client, args115, ctx) => {
+      const [result, apiCall] = await productsDisable(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73292,9 +74810,9 @@ The product will no longer be available, but will remain in the system for histo
 
 // src/funcs/productsGet.ts
 function productsGet(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) => GetProductRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73376,20 +74894,20 @@ var init_productsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/productsGet.ts
-var args110, tool$productsGet;
+var args115, tool$productsGet;
 var init_productsGet2 = __esm(() => {
   init_productsGet();
   init_operations();
   init_tools();
-  args110 = {
+  args115 = {
     request: GetProductRequest$inboundSchema
   };
   tool$productsGet = {
     name: "products-get",
     description: `Retrieve a product by ID.`,
-    args: args110,
-    tool: async (client, args111, ctx) => {
-      const [result, apiCall] = await productsGet(client, args111.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args115,
+    tool: async (client, args116, ctx) => {
+      const [result, apiCall] = await productsGet(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73404,9 +74922,9 @@ var init_productsGet2 = __esm(() => {
 
 // src/funcs/productsList.ts
 function productsList(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) => ListProductsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73489,20 +75007,20 @@ var init_productsList = __esm(() => {
 });
 
 // src/mcp-server/tools/productsList.ts
-var args111, tool$productsList;
+var args116, tool$productsList;
 var init_productsList2 = __esm(() => {
   init_productsList();
   init_operations();
   init_tools();
-  args111 = {
+  args116 = {
     request: ListProductsRequest$inboundSchema
   };
   tool$productsList = {
     name: "products-list",
     description: `List active (non-disabled) products for an account.`,
-    args: args111,
-    tool: async (client, args112, ctx) => {
-      const [result, apiCall] = await productsList(client, args112.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args116,
+    tool: async (client, args117, ctx) => {
+      const [result, apiCall] = await productsList(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73517,9 +75035,9 @@ var init_productsList2 = __esm(() => {
 
 // src/funcs/productsUpdate.ts
 function productsUpdate(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) => UpdateProductRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73617,20 +75135,20 @@ var init_productsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/productsUpdate.ts
-var args112, tool$productsUpdate;
+var args117, tool$productsUpdate;
 var init_productsUpdate2 = __esm(() => {
   init_productsUpdate();
   init_operations();
   init_tools();
-  args112 = {
+  args117 = {
     request: UpdateProductRequest$inboundSchema
   };
   tool$productsUpdate = {
     name: "products-update",
     description: `Update a product and its options.`,
-    args: args112,
-    tool: async (client, args113, ctx) => {
-      const [result, apiCall] = await productsUpdate(client, args113.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args117,
+    tool: async (client, args118, ctx) => {
+      const [result, apiCall] = await productsUpdate(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73645,9 +75163,9 @@ var init_productsUpdate2 = __esm(() => {
 
 // src/funcs/receiptsCreate.ts
 function receiptsCreate(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) => arrayType(ReceiptRequest$outboundSchema).parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73735,13 +75253,13 @@ var init_receiptsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/receiptsCreate.ts
-var args113, tool$receiptsCreate;
+var args118, tool$receiptsCreate;
 var init_receiptsCreate2 = __esm(() => {
   init_esm();
   init_receiptsCreate();
   init_components();
   init_tools();
-  args113 = {
+  args118 = {
     request: arrayType(ReceiptRequest$inboundSchema)
   };
   tool$receiptsCreate = {
@@ -73750,9 +75268,9 @@ var init_receiptsCreate2 = __esm(() => {
 
  To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
  you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args113,
-    tool: async (client, args114, ctx) => {
-      const [result, apiCall] = await receiptsCreate(client, args114.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args118,
+    tool: async (client, args119, ctx) => {
+      const [result, apiCall] = await receiptsCreate(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73767,9 +75285,9 @@ var init_receiptsCreate2 = __esm(() => {
 
 // src/funcs/receiptsList.ts
 function receiptsList(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) => ListReceiptsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73845,12 +75363,12 @@ var init_receiptsList = __esm(() => {
 });
 
 // src/mcp-server/tools/receiptsList.ts
-var args114, tool$receiptsList;
+var args119, tool$receiptsList;
 var init_receiptsList2 = __esm(() => {
   init_receiptsList();
   init_operations();
   init_tools();
-  args114 = {
+  args119 = {
     request: ListReceiptsRequest$inboundSchema
   };
   tool$receiptsList = {
@@ -73859,9 +75377,9 @@ var init_receiptsList2 = __esm(() => {
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
-    args: args114,
-    tool: async (client, args115, ctx) => {
-      const [result, apiCall] = await receiptsList(client, args115.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args119,
+    tool: async (client, args120, ctx) => {
+      const [result, apiCall] = await receiptsList(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73876,9 +75394,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/representativesCreate.ts
 function representativesCreate(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) => CreateRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73974,12 +75492,12 @@ var init_representativesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesCreate.ts
-var args115, tool$representativesCreate;
+var args120, tool$representativesCreate;
 var init_representativesCreate2 = __esm(() => {
   init_representativesCreate();
   init_operations();
   init_tools();
-  args115 = {
+  args120 = {
     request: CreateRepresentativeRequest$inboundSchema
   };
   tool$representativesCreate = {
@@ -73990,9 +75508,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: args115,
-    tool: async (client, args116, ctx) => {
-      const [result, apiCall] = await representativesCreate(client, args116.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args120,
+    tool: async (client, args121, ctx) => {
+      const [result, apiCall] = await representativesCreate(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74007,9 +75525,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/representativesDelete.ts
 function representativesDelete(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) => DeleteRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74097,12 +75615,12 @@ var init_representativesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesDelete.ts
-var args116, tool$representativesDelete;
+var args121, tool$representativesDelete;
 var init_representativesDelete2 = __esm(() => {
   init_representativesDelete();
   init_operations();
   init_tools();
-  args116 = {
+  args121 = {
     request: DeleteRepresentativeRequest$inboundSchema
   };
   tool$representativesDelete = {
@@ -74111,9 +75629,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: args116,
-    tool: async (client, args117, ctx) => {
-      const [result, apiCall] = await representativesDelete(client, args117.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args121,
+    tool: async (client, args122, ctx) => {
+      const [result, apiCall] = await representativesDelete(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74127,9 +75645,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/representativesGet.ts
 function representativesGet(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) => GetRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74208,12 +75726,12 @@ var init_representativesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesGet.ts
-var args117, tool$representativesGet;
+var args122, tool$representativesGet;
 var init_representativesGet2 = __esm(() => {
   init_representativesGet();
   init_operations();
   init_tools();
-  args117 = {
+  args122 = {
     request: GetRepresentativeRequest$inboundSchema
   };
   tool$representativesGet = {
@@ -74222,9 +75740,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: args117,
-    tool: async (client, args118, ctx) => {
-      const [result, apiCall] = await representativesGet(client, args118.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args122,
+    tool: async (client, args123, ctx) => {
+      const [result, apiCall] = await representativesGet(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74239,9 +75757,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.read\` scope.
 
 // src/funcs/representativesList.ts
 function representativesList(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) => ListRepresentativesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74319,12 +75837,12 @@ var init_representativesList = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesList.ts
-var args118, tool$representativesList;
+var args123, tool$representativesList;
 var init_representativesList2 = __esm(() => {
   init_representativesList();
   init_operations();
   init_tools();
-  args118 = {
+  args123 = {
     request: ListRepresentativesRequest$inboundSchema
   };
   tool$representativesList = {
@@ -74336,9 +75854,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: args118,
-    tool: async (client, args119, ctx) => {
-      const [result, apiCall] = await representativesList(client, args119.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args123,
+    tool: async (client, args124, ctx) => {
+      const [result, apiCall] = await representativesList(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74353,9 +75871,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.read\` scope.
 
 // src/funcs/representativesUpdate.ts
 function representativesUpdate(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) => UpdateRepresentativeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74449,12 +75967,12 @@ var init_representativesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/representativesUpdate.ts
-var args119, tool$representativesUpdate;
+var args124, tool$representativesUpdate;
 var init_representativesUpdate2 = __esm(() => {
   init_representativesUpdate();
   init_operations();
   init_tools();
-  args119 = {
+  args124 = {
     request: UpdateRepresentativeRequest$inboundSchema
   };
   tool$representativesUpdate = {
@@ -74476,9 +75994,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: args119,
-    tool: async (client, args120, ctx) => {
-      const [result, apiCall] = await representativesUpdate(client, args120.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args124,
+    tool: async (client, args125, ctx) => {
+      const [result, apiCall] = await representativesUpdate(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74493,9 +76011,9 @@ you'll need to specify the \`/accounts/{accountID}/representatives.write\` scope
 
 // src/funcs/schedulingCancel.ts
 function schedulingCancel(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) => CancelScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74588,12 +76106,12 @@ var init_schedulingCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingCancel.ts
-var args120, tool$schedulingCancel;
+var args125, tool$schedulingCancel;
 var init_schedulingCancel2 = __esm(() => {
   init_schedulingCancel();
   init_operations();
   init_tools();
-  args120 = {
+  args125 = {
     request: CancelScheduleRequest$inboundSchema
   };
   tool$schedulingCancel = {
@@ -74602,9 +76120,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: args120,
-    tool: async (client, args121, ctx) => {
-      const [result, apiCall] = await schedulingCancel(client, args121.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args125,
+    tool: async (client, args126, ctx) => {
+      const [result, apiCall] = await schedulingCancel(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74618,9 +76136,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/schedulingCreate.ts
 function schedulingCreate(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) => CreateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74714,12 +76232,12 @@ var init_schedulingCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingCreate.ts
-var args121, tool$schedulingCreate;
+var args126, tool$schedulingCreate;
 var init_schedulingCreate2 = __esm(() => {
   init_schedulingCreate();
   init_operations();
   init_tools();
-  args121 = {
+  args126 = {
     request: CreateScheduleRequest$inboundSchema
   };
   tool$schedulingCreate = {
@@ -74728,9 +76246,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: args121,
-    tool: async (client, args122, ctx) => {
-      const [result, apiCall] = await schedulingCreate(client, args122.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args126,
+    tool: async (client, args127, ctx) => {
+      const [result, apiCall] = await schedulingCreate(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74745,9 +76263,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/schedulingGet.ts
 function schedulingGet(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) => GetSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74829,12 +76347,12 @@ var init_schedulingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingGet.ts
-var args122, tool$schedulingGet;
+var args127, tool$schedulingGet;
 var init_schedulingGet2 = __esm(() => {
   init_schedulingGet();
   init_operations();
   init_tools();
-  args122 = {
+  args127 = {
     request: GetSchedulesRequest$inboundSchema
   };
   tool$schedulingGet = {
@@ -74843,9 +76361,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: args122,
-    tool: async (client, args123, ctx) => {
-      const [result, apiCall] = await schedulingGet(client, args123.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args127,
+    tool: async (client, args128, ctx) => {
+      const [result, apiCall] = await schedulingGet(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74860,9 +76378,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingGetOccurrance.ts
 function schedulingGetOccurrance(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) => GetScheduledOccurrenceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74945,12 +76463,12 @@ var init_schedulingGetOccurrance = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingGetOccurrance.ts
-var args123, tool$schedulingGetOccurrance;
+var args128, tool$schedulingGetOccurrance;
 var init_schedulingGetOccurrance2 = __esm(() => {
   init_schedulingGetOccurrance();
   init_operations();
   init_tools();
-  args123 = {
+  args128 = {
     request: GetScheduledOccurrenceRequest$inboundSchema
   };
   tool$schedulingGetOccurrance = {
@@ -74959,9 +76477,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: args123,
-    tool: async (client, args124, ctx) => {
-      const [result, apiCall] = await schedulingGetOccurrance(client, args124.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args128,
+    tool: async (client, args129, ctx) => {
+      const [result, apiCall] = await schedulingGetOccurrance(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74976,9 +76494,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingList.ts
 function schedulingList(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) => ListSchedulesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75062,12 +76580,12 @@ var init_schedulingList = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingList.ts
-var args124, tool$schedulingList;
+var args129, tool$schedulingList;
 var init_schedulingList2 = __esm(() => {
   init_schedulingList();
   init_operations();
   init_tools();
-  args124 = {
+  args129 = {
     request: ListSchedulesRequest$inboundSchema
   };
   tool$schedulingList = {
@@ -75076,9 +76594,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: args124,
-    tool: async (client, args125, ctx) => {
-      const [result, apiCall] = await schedulingList(client, args125.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args129,
+    tool: async (client, args130, ctx) => {
+      const [result, apiCall] = await schedulingList(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75093,9 +76611,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/schedulingUpdate.ts
 function schedulingUpdate(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) => UpdateScheduleRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75193,12 +76711,12 @@ var init_schedulingUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/schedulingUpdate.ts
-var args125, tool$schedulingUpdate;
+var args130, tool$schedulingUpdate;
 var init_schedulingUpdate2 = __esm(() => {
   init_schedulingUpdate();
   init_operations();
   init_tools();
-  args125 = {
+  args130 = {
     request: UpdateScheduleRequest$inboundSchema
   };
   tool$schedulingUpdate = {
@@ -75207,9 +76725,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: args125,
-    tool: async (client, args126, ctx) => {
-      const [result, apiCall] = await schedulingUpdate(client, args126.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args130,
+    tool: async (client, args131, ctx) => {
+      const [result, apiCall] = await schedulingUpdate(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75224,9 +76742,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/statementsGet.ts
 function statementsGet(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) => GetStatementRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75312,12 +76830,12 @@ var init_statementsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/statementsGet.ts
-var args126, tool$statementsGet;
+var args131, tool$statementsGet;
 var init_statementsGet2 = __esm(() => {
   init_statementsGet();
   init_operations();
   init_tools();
-  args126 = {
+  args131 = {
     request: GetStatementRequest$inboundSchema
   };
   tool$statementsGet = {
@@ -75328,9 +76846,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: args126,
-    tool: async (client, args127, ctx) => {
-      const [result, apiCall] = await statementsGet(client, args127.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args131,
+    tool: async (client, args132, ctx) => {
+      const [result, apiCall] = await statementsGet(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75345,9 +76863,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/statementsList.ts
 function statementsList(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) => ListStatementsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75433,12 +76951,12 @@ var init_statementsList = __esm(() => {
 });
 
 // src/mcp-server/tools/statementsList.ts
-var args127, tool$statementsList;
+var args132, tool$statementsList;
 var init_statementsList2 = __esm(() => {
   init_statementsList();
   init_operations();
   init_tools();
-  args127 = {
+  args132 = {
     request: ListStatementsRequest$inboundSchema
   };
   tool$statementsList = {
@@ -75447,9 +76965,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: args127,
-    tool: async (client, args128, ctx) => {
-      const [result, apiCall] = await statementsList(client, args128.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args132,
+    tool: async (client, args133, ctx) => {
+      const [result, apiCall] = await statementsList(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75464,9 +76982,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/supportCreateTicket.ts
 function supportCreateTicket(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) => CreateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75558,12 +77076,12 @@ var init_supportCreateTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportCreateTicket.ts
-var args128, tool$supportCreateTicket;
+var args133, tool$supportCreateTicket;
 var init_supportCreateTicket2 = __esm(() => {
   init_supportCreateTicket();
   init_operations();
   init_tools();
-  args128 = {
+  args133 = {
     request: CreateTicketRequest$inboundSchema
   };
   tool$supportCreateTicket = {
@@ -75575,9 +77093,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: args128,
-    tool: async (client, args129, ctx) => {
-      const [result, apiCall] = await supportCreateTicket(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args133,
+    tool: async (client, args134, ctx) => {
+      const [result, apiCall] = await supportCreateTicket(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75592,9 +77110,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{acco
 
 // src/funcs/supportGetTicket.ts
 function supportGetTicket(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) => GetTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75676,12 +77194,12 @@ var init_supportGetTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportGetTicket.ts
-var args129, tool$supportGetTicket;
+var args134, tool$supportGetTicket;
 var init_supportGetTicket2 = __esm(() => {
   init_supportGetTicket();
   init_operations();
   init_tools();
-  args129 = {
+  args134 = {
     request: GetTicketRequest$inboundSchema
   };
   tool$supportGetTicket = {
@@ -75693,9 +77211,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: args129,
-    tool: async (client, args130, ctx) => {
-      const [result, apiCall] = await supportGetTicket(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args134,
+    tool: async (client, args135, ctx) => {
+      const [result, apiCall] = await supportGetTicket(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75710,9 +77228,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportListTicketMessages.ts
 function supportListTicketMessages(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) => ListTicketMessagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75794,12 +77312,12 @@ var init_supportListTicketMessages = __esm(() => {
 });
 
 // src/mcp-server/tools/supportListTicketMessages.ts
-var args130, tool$supportListTicketMessages;
+var args135, tool$supportListTicketMessages;
 var init_supportListTicketMessages2 = __esm(() => {
   init_supportListTicketMessages();
   init_operations();
   init_tools();
-  args130 = {
+  args135 = {
     request: ListTicketMessagesRequest$inboundSchema
   };
   tool$supportListTicketMessages = {
@@ -75811,9 +77329,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: args130,
-    tool: async (client, args131, ctx) => {
-      const [result, apiCall] = await supportListTicketMessages(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args135,
+    tool: async (client, args136, ctx) => {
+      const [result, apiCall] = await supportListTicketMessages(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75828,9 +77346,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportListTickets.ts
 function supportListTickets(client, request, options) {
-  return new APIPromise($do131(client, request, options));
+  return new APIPromise($do136(client, request, options));
 }
-async function $do131(client, request, options) {
+async function $do136(client, request, options) {
   const parsed = safeParse(request, (value) => ListTicketsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75915,12 +77433,12 @@ var init_supportListTickets = __esm(() => {
 });
 
 // src/mcp-server/tools/supportListTickets.ts
-var args131, tool$supportListTickets;
+var args136, tool$supportListTickets;
 var init_supportListTickets2 = __esm(() => {
   init_supportListTickets();
   init_operations();
   init_tools();
-  args131 = {
+  args136 = {
     request: ListTicketsRequest$inboundSchema
   };
   tool$supportListTickets = {
@@ -75932,9 +77450,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: args131,
-    tool: async (client, args132, ctx) => {
-      const [result, apiCall] = await supportListTickets(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args136,
+    tool: async (client, args137, ctx) => {
+      const [result, apiCall] = await supportListTickets(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75949,9 +77467,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.read\` and \`/accounts/{accou
 
 // src/funcs/supportUpdateTicket.ts
 function supportUpdateTicket(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) => UpdateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76047,12 +77565,12 @@ var init_supportUpdateTicket = __esm(() => {
 });
 
 // src/mcp-server/tools/supportUpdateTicket.ts
-var args132, tool$supportUpdateTicket;
+var args137, tool$supportUpdateTicket;
 var init_supportUpdateTicket2 = __esm(() => {
   init_supportUpdateTicket();
   init_operations();
   init_tools();
-  args132 = {
+  args137 = {
     request: UpdateTicketRequest$inboundSchema
   };
   tool$supportUpdateTicket = {
@@ -76064,9 +77582,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: args132,
-    tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await supportUpdateTicket(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await supportUpdateTicket(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76081,9 +77599,9 @@ specify the \`/accounts/{partnerAccountID}/tickets.write\` and \`/accounts/{acco
 
 // src/funcs/sweepsCreateConfig.ts
 function sweepsCreateConfig(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) => CreateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76175,12 +77693,12 @@ var init_sweepsCreateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsCreateConfig.ts
-var args133, tool$sweepsCreateConfig;
+var args138, tool$sweepsCreateConfig;
 var init_sweepsCreateConfig2 = __esm(() => {
   init_sweepsCreateConfig();
   init_operations();
   init_tools();
-  args133 = {
+  args138 = {
     request: CreateSweepConfigRequest$inboundSchema
   };
   tool$sweepsCreateConfig = {
@@ -76189,9 +77707,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: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await sweepsCreateConfig(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args138,
+    tool: async (client, args139, ctx) => {
+      const [result, apiCall] = await sweepsCreateConfig(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76206,9 +77724,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/sweepsGet.ts
 function sweepsGet(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) => GetSweepRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76294,12 +77812,12 @@ var init_sweepsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGet.ts
-var args134, tool$sweepsGet;
+var args139, tool$sweepsGet;
 var init_sweepsGet2 = __esm(() => {
   init_sweepsGet();
   init_operations();
   init_tools();
-  args134 = {
+  args139 = {
     request: GetSweepRequest$inboundSchema
   };
   tool$sweepsGet = {
@@ -76308,9 +77826,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: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await sweepsGet(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args139,
+    tool: async (client, args140, ctx) => {
+      const [result, apiCall] = await sweepsGet(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76325,9 +77843,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsGetConfig.ts
 function sweepsGetConfig(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) => GetSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76409,12 +77927,12 @@ var init_sweepsGetConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsGetConfig.ts
-var args135, tool$sweepsGetConfig;
+var args140, tool$sweepsGetConfig;
 var init_sweepsGetConfig2 = __esm(() => {
   init_sweepsGetConfig();
   init_operations();
   init_tools();
-  args135 = {
+  args140 = {
     request: GetSweepConfigRequest$inboundSchema
   };
   tool$sweepsGetConfig = {
@@ -76423,9 +77941,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: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await sweepsGetConfig(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args140,
+    tool: async (client, args141, ctx) => {
+      const [result, apiCall] = await sweepsGetConfig(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76440,9 +77958,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsList.ts
 function sweepsList(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) => ListSweepsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76531,12 +78049,12 @@ var init_sweepsList = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsList.ts
-var args136, tool$sweepsList;
+var args141, tool$sweepsList;
 var init_sweepsList2 = __esm(() => {
   init_sweepsList();
   init_operations();
   init_tools();
-  args136 = {
+  args141 = {
     request: ListSweepsRequest$inboundSchema
   };
   tool$sweepsList = {
@@ -76545,9 +78063,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: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await sweepsList(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args141,
+    tool: async (client, args142, ctx) => {
+      const [result, apiCall] = await sweepsList(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76562,9 +78080,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsListConfigs.ts
 function sweepsListConfigs(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) => ListSweepConfigsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76642,12 +78160,12 @@ var init_sweepsListConfigs = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsListConfigs.ts
-var args137, tool$sweepsListConfigs;
+var args142, tool$sweepsListConfigs;
 var init_sweepsListConfigs2 = __esm(() => {
   init_sweepsListConfigs();
   init_operations();
   init_tools();
-  args137 = {
+  args142 = {
     request: ListSweepConfigsRequest$inboundSchema
   };
   tool$sweepsListConfigs = {
@@ -76656,9 +78174,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: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await sweepsListConfigs(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args142,
+    tool: async (client, args143, ctx) => {
+      const [result, apiCall] = await sweepsListConfigs(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76673,9 +78191,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/sweepsUpdateConfig.ts
 function sweepsUpdateConfig(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) => UpdateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76771,12 +78289,12 @@ var init_sweepsUpdateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsUpdateConfig.ts
-var args138, tool$sweepsUpdateConfig;
+var args143, tool$sweepsUpdateConfig;
 var init_sweepsUpdateConfig2 = __esm(() => {
   init_sweepsUpdateConfig();
   init_operations();
   init_tools();
-  args138 = {
+  args143 = {
     request: UpdateSweepConfigRequest$inboundSchema
   };
   tool$sweepsUpdateConfig = {
@@ -76785,9 +78303,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: args138,
-    tool: async (client, args139, ctx) => {
-      const [result, apiCall] = await sweepsUpdateConfig(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args143,
+    tool: async (client, args144, ctx) => {
+      const [result, apiCall] = await sweepsUpdateConfig(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76802,9 +78320,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreate.ts
 function terminalApplicationsCreate(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) => CreateTerminalApplication$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -76893,12 +78411,12 @@ var init_terminalApplicationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreate.ts
-var args139, tool$terminalApplicationsCreate;
+var args144, tool$terminalApplicationsCreate;
 var init_terminalApplicationsCreate2 = __esm(() => {
   init_terminalApplicationsCreate();
   init_components();
   init_tools();
-  args139 = {
+  args144 = {
     request: CreateTerminalApplication$inboundSchema
   };
   tool$terminalApplicationsCreate = {
@@ -76907,9 +78425,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: args139,
-    tool: async (client, args140, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreate(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args144,
+    tool: async (client, args145, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreate(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -76924,9 +78442,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreateVersion.ts
 function terminalApplicationsCreateVersion(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) => CreateTerminalApplicationVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77016,12 +78534,12 @@ var init_terminalApplicationsCreateVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreateVersion.ts
-var args140, tool$terminalApplicationsCreateVersion;
+var args145, tool$terminalApplicationsCreateVersion;
 var init_terminalApplicationsCreateVersion2 = __esm(() => {
   init_terminalApplicationsCreateVersion();
   init_operations();
   init_tools();
-  args140 = {
+  args145 = {
     request: CreateTerminalApplicationVersionRequest$inboundSchema
   };
   tool$terminalApplicationsCreateVersion = {
@@ -77030,9 +78548,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: args140,
-    tool: async (client, args141, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args145,
+    tool: async (client, args146, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77047,9 +78565,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsDelete.ts
 function terminalApplicationsDelete(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) => DeleteTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77133,12 +78651,12 @@ var init_terminalApplicationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsDelete.ts
-var args141, tool$terminalApplicationsDelete;
+var args146, tool$terminalApplicationsDelete;
 var init_terminalApplicationsDelete2 = __esm(() => {
   init_terminalApplicationsDelete();
   init_operations();
   init_tools();
-  args141 = {
+  args146 = {
     request: DeleteTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsDelete = {
@@ -77147,9 +78665,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: args141,
-    tool: async (client, args142, ctx) => {
-      const [result, apiCall] = await terminalApplicationsDelete(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args146,
+    tool: async (client, args147, ctx) => {
+      const [result, apiCall] = await terminalApplicationsDelete(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77163,9 +78681,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsGet.ts
 function terminalApplicationsGet(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) => GetTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77240,12 +78758,12 @@ var init_terminalApplicationsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsGet.ts
-var args142, tool$terminalApplicationsGet;
+var args147, tool$terminalApplicationsGet;
 var init_terminalApplicationsGet2 = __esm(() => {
   init_terminalApplicationsGet();
   init_operations();
   init_tools();
-  args142 = {
+  args147 = {
     request: GetTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsGet = {
@@ -77254,9 +78772,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: args142,
-    tool: async (client, args143, ctx) => {
-      const [result, apiCall] = await terminalApplicationsGet(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args147,
+    tool: async (client, args148, ctx) => {
+      const [result, apiCall] = await terminalApplicationsGet(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77271,9 +78789,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/terminalApplicationsList.ts
 function terminalApplicationsList(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 path = pathToFunc("/terminal-applications")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -77337,12 +78855,12 @@ var init_terminalApplicationsList = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsList.ts
-var args143, tool$terminalApplicationsList;
+var args148, tool$terminalApplicationsList;
 var init_terminalApplicationsList2 = __esm(() => {
   init_terminalApplicationsList();
   init_operations();
   init_tools();
-  args143 = {
+  args148 = {
     request: ListTerminalApplicationsRequest$inboundSchema
   };
   tool$terminalApplicationsList = {
@@ -77351,9 +78869,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: args143,
-    tool: async (client, args144, ctx) => {
-      const [result, apiCall] = await terminalApplicationsList(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args148,
+    tool: async (client, args149, ctx) => {
+      const [result, apiCall] = await terminalApplicationsList(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77368,9 +78886,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/transfersCreate.ts
 function transfersCreate(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) => CreateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77463,12 +78981,12 @@ var init_transfersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreate.ts
-var args144, tool$transfersCreate;
+var args149, tool$transfersCreate;
 var init_transfersCreate2 = __esm(() => {
   init_transfersCreate();
   init_operations();
   init_tools();
-  args144 = {
+  args149 = {
     request: CreateTransferRequest$inboundSchema
   };
   tool$transfersCreate = {
@@ -77479,9 +78997,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: args144,
-    tool: async (client, args145, ctx) => {
-      const [result, apiCall] = await transfersCreate(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args149,
+    tool: async (client, args150, ctx) => {
+      const [result, apiCall] = await transfersCreate(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77496,9 +79014,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersCreateCancellation.ts
 function transfersCreateCancellation(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) => CreateCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77581,12 +79099,12 @@ var init_transfersCreateCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateCancellation.ts
-var args145, tool$transfersCreateCancellation;
+var args150, tool$transfersCreateCancellation;
 var init_transfersCreateCancellation2 = __esm(() => {
   init_transfersCreateCancellation();
   init_operations();
   init_tools();
-  args145 = {
+  args150 = {
     request: CreateCancellationRequest$inboundSchema
   };
   tool$transfersCreateCancellation = {
@@ -77595,9 +79113,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: args145,
-    tool: async (client, args146, ctx) => {
-      const [result, apiCall] = await transfersCreateCancellation(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args150,
+    tool: async (client, args151, ctx) => {
+      const [result, apiCall] = await transfersCreateCancellation(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77612,9 +79130,9 @@ var init_transfersCreateCancellation2 = __esm(() => {
 
 // src/funcs/transfersCreateReversal.ts
 function transfersCreateReversal(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) => CreateReversalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77713,12 +79231,12 @@ var init_transfersCreateReversal = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateReversal.ts
-var args146, tool$transfersCreateReversal;
+var args151, tool$transfersCreateReversal;
 var init_transfersCreateReversal2 = __esm(() => {
   init_transfersCreateReversal();
   init_operations();
   init_tools();
-  args146 = {
+  args151 = {
     request: CreateReversalRequest$inboundSchema
   };
   tool$transfersCreateReversal = {
@@ -77729,9 +79247,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: args146,
-    tool: async (client, args147, ctx) => {
-      const [result, apiCall] = await transfersCreateReversal(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args151,
+    tool: async (client, args152, ctx) => {
+      const [result, apiCall] = await transfersCreateReversal(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77746,9 +79264,9 @@ to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGenerateOptions.ts
 function transfersGenerateOptions(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) => CreateTransferOptionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77832,12 +79350,12 @@ var init_transfersGenerateOptions = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGenerateOptions.ts
-var args147, tool$transfersGenerateOptions;
+var args152, tool$transfersGenerateOptions;
 var init_transfersGenerateOptions2 = __esm(() => {
   init_transfersGenerateOptions();
   init_operations();
   init_tools();
-  args147 = {
+  args152 = {
     request: CreateTransferOptionsRequest$inboundSchema
   };
   tool$transfersGenerateOptions = {
@@ -77851,9 +79369,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: args147,
-    tool: async (client, args148, ctx) => {
-      const [result, apiCall] = await transfersGenerateOptions(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args152,
+    tool: async (client, args153, ctx) => {
+      const [result, apiCall] = await transfersGenerateOptions(client, args153.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77868,9 +79386,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGet.ts
 function transfersGet(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) => GetTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -77952,12 +79470,12 @@ var init_transfersGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGet.ts
-var args148, tool$transfersGet;
+var args153, tool$transfersGet;
 var init_transfersGet2 = __esm(() => {
   init_transfersGet();
   init_operations();
   init_tools();
-  args148 = {
+  args153 = {
     request: GetTransferRequest$inboundSchema
   };
   tool$transfersGet = {
@@ -77969,9 +79487,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: args148,
-    tool: async (client, args149, ctx) => {
-      const [result, apiCall] = await transfersGet(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args153,
+    tool: async (client, args154, ctx) => {
+      const [result, apiCall] = await transfersGet(client, args154.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -77986,9 +79504,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersGetCancellation.ts
 function transfersGetCancellation(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) => GetCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78074,12 +79592,12 @@ var init_transfersGetCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetCancellation.ts
-var args149, tool$transfersGetCancellation;
+var args154, tool$transfersGetCancellation;
 var init_transfersGetCancellation2 = __esm(() => {
   init_transfersGetCancellation();
   init_operations();
   init_tools();
-  args149 = {
+  args154 = {
     request: GetCancellationRequest$inboundSchema
   };
   tool$transfersGetCancellation = {
@@ -78088,9 +79606,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: args149,
-    tool: async (client, args150, ctx) => {
-      const [result, apiCall] = await transfersGetCancellation(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args154,
+    tool: async (client, args155, ctx) => {
+      const [result, apiCall] = await transfersGetCancellation(client, args155.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78105,9 +79623,9 @@ var init_transfersGetCancellation2 = __esm(() => {
 
 // src/funcs/transfersGetRefund.ts
 function transfersGetRefund(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) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78193,12 +79711,12 @@ var init_transfersGetRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetRefund.ts
-var args150, tool$transfersGetRefund;
+var args155, tool$transfersGetRefund;
 var init_transfersGetRefund2 = __esm(() => {
   init_transfersGetRefund();
   init_operations();
   init_tools();
-  args150 = {
+  args155 = {
     request: GetRefundRequest$inboundSchema
   };
   tool$transfersGetRefund = {
@@ -78207,9 +79725,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: args150,
-    tool: async (client, args151, ctx) => {
-      const [result, apiCall] = await transfersGetRefund(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args155,
+    tool: async (client, args156, ctx) => {
+      const [result, apiCall] = await transfersGetRefund(client, args156.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78224,9 +79742,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersInitiateRefund.ts
 function transfersInitiateRefund(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) => InitiateRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78318,12 +79836,12 @@ var init_transfersInitiateRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersInitiateRefund.ts
-var args151, tool$transfersInitiateRefund;
+var args156, tool$transfersInitiateRefund;
 var init_transfersInitiateRefund2 = __esm(() => {
   init_transfersInitiateRefund();
   init_operations();
   init_tools();
-  args151 = {
+  args156 = {
     request: InitiateRefundRequest$inboundSchema
   };
   tool$transfersInitiateRefund = {
@@ -78335,9 +79853,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: args151,
-    tool: async (client, args152, ctx) => {
-      const [result, apiCall] = await transfersInitiateRefund(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args156,
+    tool: async (client, args157, ctx) => {
+      const [result, apiCall] = await transfersInitiateRefund(client, args157.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78352,9 +79870,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersList.ts
 function transfersList(client, request, options) {
-  return new APIPromise($do152(client, request, options));
+  return new APIPromise($do157(client, request, options));
 }
-async function $do152(client, request, options) {
+async function $do157(client, request, options) {
   const parsed = safeParse(request, (value) => ListTransfersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78450,12 +79968,12 @@ var init_transfersList = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersList.ts
-var args152, tool$transfersList;
+var args157, tool$transfersList;
 var init_transfersList2 = __esm(() => {
   init_transfersList();
   init_operations();
   init_tools();
-  args152 = {
+  args157 = {
     request: ListTransfersRequest$inboundSchema
   };
   tool$transfersList = {
@@ -78471,9 +79989,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: args152,
-    tool: async (client, args153, ctx) => {
-      const [result, apiCall] = await transfersList(client, args153.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args157,
+    tool: async (client, args158, ctx) => {
+      const [result, apiCall] = await transfersList(client, args158.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78488,9 +80006,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersListRefunds.ts
 function transfersListRefunds(client, request, options) {
-  return new APIPromise($do153(client, request, options));
+  return new APIPromise($do158(client, request, options));
 }
-async function $do153(client, request, options) {
+async function $do158(client, request, options) {
   const parsed = safeParse(request, (value) => ListRefundsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78572,12 +80090,12 @@ var init_transfersListRefunds = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersListRefunds.ts
-var args153, tool$transfersListRefunds;
+var args158, tool$transfersListRefunds;
 var init_transfersListRefunds2 = __esm(() => {
   init_transfersListRefunds();
   init_operations();
   init_tools();
-  args153 = {
+  args158 = {
     request: ListRefundsRequest$inboundSchema
   };
   tool$transfersListRefunds = {
@@ -78586,9 +80104,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: args153,
-    tool: async (client, args154, ctx) => {
-      const [result, apiCall] = await transfersListRefunds(client, args154.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args158,
+    tool: async (client, args159, ctx) => {
+      const [result, apiCall] = await transfersListRefunds(client, args159.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78603,9 +80121,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersUpdate.ts
 function transfersUpdate(client, request, options) {
-  return new APIPromise($do154(client, request, options));
+  return new APIPromise($do159(client, request, options));
 }
-async function $do154(client, request, options) {
+async function $do159(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78691,12 +80209,12 @@ var init_transfersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersUpdate.ts
-var args154, tool$transfersUpdate;
+var args159, tool$transfersUpdate;
 var init_transfersUpdate2 = __esm(() => {
   init_transfersUpdate();
   init_operations();
   init_tools();
-  args154 = {
+  args159 = {
     request: UpdateTransferRequest$inboundSchema
   };
   tool$transfersUpdate = {
@@ -78707,9 +80225,9 @@ Read our [transfers overview guide](https://docs.moov.io/guides/money-movement/o
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args154,
-    tool: async (client, args155, ctx) => {
-      const [result, apiCall] = await transfersUpdate(client, args155.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args159,
+    tool: async (client, args160, ctx) => {
+      const [result, apiCall] = await transfersUpdate(client, args160.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78724,9 +80242,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/underwritingGet.ts
 function underwritingGet(client, request, options) {
-  return new APIPromise($do155(client, request, options));
+  return new APIPromise($do160(client, request, options));
 }
-async function $do155(client, request, options) {
+async function $do160(client, request, options) {
   const parsed = safeParse(request, (value) => GetUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78804,12 +80322,12 @@ var init_underwritingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingGet.ts
-var args155, tool$underwritingGet;
+var args160, tool$underwritingGet;
 var init_underwritingGet2 = __esm(() => {
   init_underwritingGet();
   init_operations();
   init_tools();
-  args155 = {
+  args160 = {
     request: GetUnderwritingRequest$inboundSchema
   };
   tool$underwritingGet = {
@@ -78820,9 +80338,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: args155,
-    tool: async (client, args156, ctx) => {
-      const [result, apiCall] = await underwritingGet(client, args156.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args160,
+    tool: async (client, args161, ctx) => {
+      const [result, apiCall] = await underwritingGet(client, args161.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78837,9 +80355,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/underwritingSave.ts
 function underwritingSave(client, request, options) {
-  return new APIPromise($do156(client, request, options));
+  return new APIPromise($do161(client, request, options));
 }
-async function $do156(client, request, options) {
+async function $do161(client, request, options) {
   const parsed = safeParse(request, (value) => SaveUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -78935,12 +80453,12 @@ var init_underwritingSave = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingSave.ts
-var args156, tool$underwritingSave;
+var args161, tool$underwritingSave;
 var init_underwritingSave2 = __esm(() => {
   init_underwritingSave();
   init_operations();
   init_tools();
-  args156 = {
+  args161 = {
     request: SaveUnderwritingRequest$inboundSchema
   };
   tool$underwritingSave = {
@@ -78951,9 +80469,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: args156,
-    tool: async (client, args157, ctx) => {
-      const [result, apiCall] = await underwritingSave(client, args157.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args161,
+    tool: async (client, args162, ctx) => {
+      const [result, apiCall] = await underwritingSave(client, args162.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -78968,9 +80486,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/underwritingUpsert.ts
 function underwritingUpsert(client, request, options) {
-  return new APIPromise($do157(client, request, options));
+  return new APIPromise($do162(client, request, options));
 }
-async function $do157(client, request, options) {
+async function $do162(client, request, options) {
   const parsed = safeParse(request, (value) => UpsertUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79066,12 +80584,12 @@ var init_underwritingUpsert = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingUpsert.ts
-var args157, tool$underwritingUpsert;
+var args162, tool$underwritingUpsert;
 var init_underwritingUpsert2 = __esm(() => {
   init_underwritingUpsert();
   init_operations();
   init_tools();
-  args157 = {
+  args162 = {
     request: UpsertUnderwritingRequest$inboundSchema
   };
   tool$underwritingUpsert = {
@@ -79082,9 +80600,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: args157,
-    tool: async (client, args158, ctx) => {
-      const [result, apiCall] = await underwritingUpsert(client, args158.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args162,
+    tool: async (client, args163, ctx) => {
+      const [result, apiCall] = await underwritingUpsert(client, args163.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79099,9 +80617,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/walletsCreate.ts
 function walletsCreate(client, request, options) {
-  return new APIPromise($do158(client, request, options));
+  return new APIPromise($do163(client, request, options));
 }
-async function $do158(client, request, options) {
+async function $do163(client, request, options) {
   const parsed = safeParse(request, (value) => CreateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79195,12 +80713,12 @@ var init_walletsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsCreate.ts
-var args158, tool$walletsCreate;
+var args163, tool$walletsCreate;
 var init_walletsCreate2 = __esm(() => {
   init_walletsCreate();
   init_operations();
   init_tools();
-  args158 = {
+  args163 = {
     request: CreateWalletRequest$inboundSchema
   };
   tool$walletsCreate = {
@@ -79211,9 +80729,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: args158,
-    tool: async (client, args159, ctx) => {
-      const [result, apiCall] = await walletsCreate(client, args159.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args163,
+    tool: async (client, args164, ctx) => {
+      const [result, apiCall] = await walletsCreate(client, args164.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79228,9 +80746,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletsGet.ts
 function walletsGet(client, request, options) {
-  return new APIPromise($do159(client, request, options));
+  return new APIPromise($do164(client, request, options));
 }
-async function $do159(client, request, options) {
+async function $do164(client, request, options) {
   const parsed = safeParse(request, (value) => GetWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79312,12 +80830,12 @@ var init_walletsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsGet.ts
-var args159, tool$walletsGet;
+var args164, tool$walletsGet;
 var init_walletsGet2 = __esm(() => {
   init_walletsGet();
   init_operations();
   init_tools();
-  args159 = {
+  args164 = {
     request: GetWalletRequest$inboundSchema
   };
   tool$walletsGet = {
@@ -79328,9 +80846,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: args159,
-    tool: async (client, args160, ctx) => {
-      const [result, apiCall] = await walletsGet(client, args160.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args164,
+    tool: async (client, args165, ctx) => {
+      const [result, apiCall] = await walletsGet(client, args165.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79345,9 +80863,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsList.ts
 function walletsList(client, request, options) {
-  return new APIPromise($do160(client, request, options));
+  return new APIPromise($do165(client, request, options));
 }
-async function $do160(client, request, options) {
+async function $do165(client, request, options) {
   const parsed = safeParse(request, (value) => ListWalletsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79435,12 +80953,12 @@ var init_walletsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsList.ts
-var args160, tool$walletsList;
+var args165, tool$walletsList;
 var init_walletsList2 = __esm(() => {
   init_walletsList();
   init_operations();
   init_tools();
-  args160 = {
+  args165 = {
     request: ListWalletsRequest$inboundSchema
   };
   tool$walletsList = {
@@ -79451,9 +80969,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: args160,
-    tool: async (client, args161, ctx) => {
-      const [result, apiCall] = await walletsList(client, args161.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args165,
+    tool: async (client, args166, ctx) => {
+      const [result, apiCall] = await walletsList(client, args166.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79468,9 +80986,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsUpdate.ts
 function walletsUpdate(client, request, options) {
-  return new APIPromise($do161(client, request, options));
+  return new APIPromise($do166(client, request, options));
 }
-async function $do161(client, request, options) {
+async function $do166(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79568,12 +81086,12 @@ var init_walletsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsUpdate.ts
-var args161, tool$walletsUpdate;
+var args166, tool$walletsUpdate;
 var init_walletsUpdate2 = __esm(() => {
   init_walletsUpdate();
   init_operations();
   init_tools();
-  args161 = {
+  args166 = {
     request: UpdateWalletRequest$inboundSchema
   };
   tool$walletsUpdate = {
@@ -79584,9 +81102,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: args161,
-    tool: async (client, args162, ctx) => {
-      const [result, apiCall] = await walletsUpdate(client, args162.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args166,
+    tool: async (client, args167, ctx) => {
+      const [result, apiCall] = await walletsUpdate(client, args167.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79601,9 +81119,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletTransactionsGet.ts
 function walletTransactionsGet(client, request, options) {
-  return new APIPromise($do162(client, request, options));
+  return new APIPromise($do167(client, request, options));
 }
-async function $do162(client, request, options) {
+async function $do167(client, request, options) {
   const parsed = safeParse(request, (value) => GetWalletTransactionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79689,12 +81207,12 @@ var init_walletTransactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsGet.ts
-var args162, tool$walletTransactionsGet;
+var args167, tool$walletTransactionsGet;
 var init_walletTransactionsGet2 = __esm(() => {
   init_walletTransactionsGet();
   init_operations();
   init_tools();
-  args162 = {
+  args167 = {
     request: GetWalletTransactionRequest$inboundSchema
   };
   tool$walletTransactionsGet = {
@@ -79705,9 +81223,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: args162,
-    tool: async (client, args163, ctx) => {
-      const [result, apiCall] = await walletTransactionsGet(client, args163.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args167,
+    tool: async (client, args168, ctx) => {
+      const [result, apiCall] = await walletTransactionsGet(client, args168.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79722,9 +81240,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletTransactionsList.ts
 function walletTransactionsList(client, request, options) {
-  return new APIPromise($do163(client, request, options));
+  return new APIPromise($do168(client, request, options));
 }
-async function $do163(client, request, options) {
+async function $do168(client, request, options) {
   const parsed = safeParse(request, (value) => ListWalletTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -79824,12 +81342,12 @@ var init_walletTransactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsList.ts
-var args163, tool$walletTransactionsList;
+var args168, tool$walletTransactionsList;
 var init_walletTransactionsList2 = __esm(() => {
   init_walletTransactionsList();
   init_operations();
   init_tools();
-  args163 = {
+  args168 = {
     request: ListWalletTransactionsRequest$inboundSchema
   };
   tool$walletTransactionsList = {
@@ -79840,9 +81358,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: args163,
-    tool: async (client, args164, ctx) => {
-      const [result, apiCall] = await walletTransactionsList(client, args164.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args168,
+    tool: async (client, args169, ctx) => {
+      const [result, apiCall] = await walletTransactionsList(client, args169.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -79859,7 +81377,7 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Moov",
-    version: "0.21.14"
+    version: "0.21.15"
   });
   const client = new MoovCore({
     security: deps.security,
@@ -79944,6 +81462,11 @@ function createMCPServer(deps) {
   tool(tool$imagesDelete);
   tool(tool$imagesUpdateMetadata);
   tool(tool$imagesGetPublic);
+  tool(tool$invoicesCreateInvoice);
+  tool(tool$invoicesListInvoices);
+  tool(tool$invoicesGetInvoice);
+  tool(tool$invoicesUpdateInvoice);
+  tool(tool$invoicesMarkPaidInvoice);
   tool(tool$paymentLinksCreate);
   tool(tool$paymentLinksList);
   tool(tool$paymentLinksGet);
@@ -80133,6 +81656,11 @@ var init_server2 = __esm(() => {
   init_industriesList2();
   init_institutionsSearch2();
   init_institutionsSearchInstitutions2();
+  init_invoicesCreateInvoice2();
+  init_invoicesGetInvoice2();
+  init_invoicesListInvoices2();
+  init_invoicesMarkPaidInvoice2();
+  init_invoicesUpdateInvoice2();
   init_issuingTransactionsGet2();
   init_issuingTransactionsGetAuthorization2();
   init_issuingTransactionsList2();
@@ -81409,7 +82937,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.21.14"
+    currentVersion: "0.21.15"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -81417,5 +82945,5 @@ export {
   app
 };
 
-//# debugId=0FAAFFB6B2EDF80264756E2164756E21
+//# debugId=88F89244FDD160AE64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map