@moovio/sdk 25.1.1 → 25.7.0

package/bin/mcp-server.js

@@ -52412,10 +52412,10 @@ var init_config = __esm(() => {
   ];
   SDK_METADATA = {
     language: "typescript",
-    openapiDocVersion: "v2025.01.00",
-    sdkVersion: "25.1.1",
+    openapiDocVersion: "v2025.07.00",
+    sdkVersion: "25.7.0",
     genVersion: "2.803.3",
-    userAgent: "speakeasy-sdk/typescript 25.1.1 2.803.3 v2025.01.00 @moovio/sdk"
+    userAgent: "speakeasy-sdk/typescript 25.7.0 2.803.3 v2025.07.00 @moovio/sdk"
   };
 });
 
@@ -54230,7 +54230,8 @@ var init_accounttype = __esm(() => {
   init_esm();
   AccountType = {
     Individual: "individual",
-    Business: "business"
+    Business: "business",
+    Guest: "guest"
   };
   AccountType$inboundSchema = nativeEnumType(AccountType);
   AccountType$outboundSchema = AccountType$inboundSchema;
@@ -54471,6 +54472,23 @@ var init_businessprofile = __esm(() => {
   });
 });
 
+// src/models/components/guestprofile.ts
+var GuestProfile$inboundSchema, GuestProfile$outboundSchema;
+var init_guestprofile = __esm(() => {
+  init_esm();
+  init_phonenumber();
+  GuestProfile$inboundSchema = objectType({
+    name: stringType(),
+    phone: PhoneNumber$inboundSchema.optional(),
+    email: stringType().optional()
+  });
+  GuestProfile$outboundSchema = objectType({
+    name: stringType(),
+    phone: PhoneNumber$outboundSchema.optional(),
+    email: stringType().optional()
+  });
+});
+
 // src/models/components/individualprofile.ts
 var IndividualProfile$inboundSchema, IndividualProfile$outboundSchema;
 var init_individualprofile = __esm(() => {
@@ -54501,14 +54519,17 @@ var Profile$inboundSchema, Profile$outboundSchema;
 var init_profile = __esm(() => {
   init_esm();
   init_businessprofile();
+  init_guestprofile();
   init_individualprofile();
   Profile$inboundSchema = objectType({
     individual: IndividualProfile$inboundSchema.optional(),
-    business: BusinessProfile$inboundSchema.optional()
+    business: BusinessProfile$inboundSchema.optional(),
+    guest: GuestProfile$inboundSchema.optional()
   });
   Profile$outboundSchema = objectType({
     individual: IndividualProfile$outboundSchema.optional(),
-    business: BusinessProfile$outboundSchema.optional()
+    business: BusinessProfile$outboundSchema.optional(),
+    guest: GuestProfile$outboundSchema.optional()
   });
 });
 
@@ -54824,7 +54845,8 @@ var init_bankaccountholdertype = __esm(() => {
   init_esm();
   BankAccountHolderType = {
     Individual: "individual",
-    Business: "business"
+    Business: "business",
+    Guest: "guest"
   };
   BankAccountHolderType$inboundSchema = nativeEnumType(BankAccountHolderType);
   BankAccountHolderType$outboundSchema = BankAccountHolderType$inboundSchema;
@@ -55286,10 +55308,21 @@ var init_capabilityid = __esm(() => {
   CapabilityID = {
     Transfers: "transfers",
     SendFunds: "send-funds",
+    SendFundsPushToCard: "send-funds.push-to-card",
+    MoneyTransferPushToCard: "money-transfer.push-to-card",
+    SendFundsAch: "send-funds.ach",
+    SendFundsRtp: "send-funds.rtp",
+    SendFundsInstantBank: "send-funds.instant-bank",
     CollectFunds: "collect-funds",
+    CollectFundsCardPayments: "collect-funds.card-payments",
+    MoneyTransferPullFromCard: "money-transfer.pull-from-card",
+    CollectFundsAch: "collect-funds.ach",
     Wallet: "wallet",
+    WalletBalance: "wallet.balance",
     CardIssuing: "card-issuing",
-    ProductionApp: "production-app"
+    ProductionApp: "production-app",
+    PlatformProductionApp: "platform.production-app",
+    PlatformWalletTransfers: "platform.wallet-transfers"
   };
   CapabilityID$inboundSchema = nativeEnumType(CapabilityID);
   CapabilityID$outboundSchema = CapabilityID$inboundSchema;
@@ -55874,7 +55907,8 @@ var init_paymentmethodtype = __esm(() => {
     CardPayment: "card-payment",
     PushToCard: "push-to-card",
     PullFromCard: "pull-from-card",
-    ApplePay: "apple-pay"
+    ApplePay: "apple-pay",
+    CardPresentPayment: "card-present-payment"
   };
   PaymentMethodType$inboundSchema = nativeEnumType(PaymentMethodType);
   PaymentMethodType$outboundSchema = PaymentMethodType$inboundSchema;
@@ -58753,6 +58787,22 @@ var init_brandproperties = __esm(() => {
   });
 });
 
+// src/models/components/businesspresence.ts
+var BusinessPresence, BusinessPresence$inboundSchema, BusinessPresence$outboundSchema;
+var init_businesspresence = __esm(() => {
+  init_esm();
+  BusinessPresence = {
+    CommercialOffice: "commercial-office",
+    HomeBased: "home-based",
+    MixedPresence: "mixed-presence",
+    MobileBusiness: "mobile-business",
+    OnlineOnly: "online-only",
+    RetailStorefront: "retail-storefront"
+  };
+  BusinessPresence$inboundSchema = nativeEnumType(BusinessPresence);
+  BusinessPresence$outboundSchema = BusinessPresence$inboundSchema;
+});
+
 // src/models/components/calltoaction.ts
 var CallToAction, CallToAction$inboundSchema, CallToAction$outboundSchema;
 var init_calltoaction = __esm(() => {
@@ -58886,7 +58936,61 @@ var init_requirementid = __esm(() => {
     RepresentativeRepUuidIsController: "representative.{rep-uuid}.is-controller",
     RepresentativeRepUuidIsOwner: "representative.{rep-uuid}.is-owner",
     RepresentativeRepUuidOwnership: "representative.{rep-uuid}.ownership",
-    DocumentDocUuid: "document.{doc-uuid}"
+    DocumentDocUuid: "document.{doc-uuid}",
+    UnderwritingBusinessPresence: "underwriting.businessPresence",
+    UnderwritingGeographicReach: "underwriting.geographicReach",
+    UnderwritingVolumeShareByCustomerType: "underwriting.volumeShareByCustomerType",
+    UnderwritingPendingLitigation: "underwriting.pendingLitigation",
+    UnderwritingDocumentsProcessingStatementsPast3Months: "underwriting.documents.processingStatementsPast3Months",
+    UnderwritingCollectFundsCardPaymentsCardAcceptanceMethods: "underwriting.collectFunds.cardPayments.cardAcceptanceMethods",
+    UnderwritingCollectFundsCardPaymentsCurrentlyAcceptsCards: "underwriting.collectFunds.cardPayments.currentlyAcceptsCards",
+    UnderwritingCollectFundsCardPaymentsEstimatedActivityAverageTransactionAmount: "underwriting.collectFunds.cardPayments.estimatedActivity.averageTransactionAmount",
+    UnderwritingCollectFundsCardPaymentsEstimatedActivityMaximumTransactionAmount: "underwriting.collectFunds.cardPayments.estimatedActivity.maximumTransactionAmount",
+    UnderwritingCollectFundsCardPaymentsEstimatedActivityMonthlyVolumeRange: "underwriting.collectFunds.cardPayments.estimatedActivity.monthlyVolumeRange",
+    UnderwritingCollectFundsCardPaymentsFulfillment: "underwriting.collectFunds.cardPayments.fulfillment",
+    UnderwritingCollectFundsCardPaymentsRefundPolicy: "underwriting.collectFunds.cardPayments.refundPolicy",
+    UnderwritingCollectFundsAchCardAcceptanceMethods: "underwriting.collectFunds.ach.cardAcceptanceMethods",
+    UnderwritingCollectFundsAchCurrentlyAcceptsCards: "underwriting.collectFunds.ach.currentlyAcceptsCards",
+    UnderwritingCollectFundsAchEstimatedActivityAverageTransactionAmount: "underwriting.collectFunds.ach.estimatedActivity.averageTransactionAmount",
+    UnderwritingCollectFundsAchEstimatedActivityMaximumTransactionAmount: "underwriting.collectFunds.ach.estimatedActivity.maximumTransactionAmount",
+    UnderwritingCollectFundsAchEstimatedActivityMonthlyVolumeRange: "underwriting.collectFunds.ach.estimatedActivity.monthlyVolumeRange",
+    UnderwritingCollectFundsAchFulfillment: "underwriting.collectFunds.ach.fulfillment",
+    UnderwritingCollectFundsAchRefundPolicy: "underwriting.collectFunds.ach.refundPolicy",
+    UnderwritingSendFundsAchCardAcceptanceMethods: "underwriting.sendFunds.ach.cardAcceptanceMethods",
+    UnderwritingSendFundsAchCurrentlyAcceptsCards: "underwriting.sendFunds.ach.currentlyAcceptsCards",
+    UnderwritingSendFundsAchEstimatedActivityAverageTransactionAmount: "underwriting.sendFunds.ach.estimatedActivity.averageTransactionAmount",
+    UnderwritingSendFundsAchEstimatedActivityMaximumTransactionAmount: "underwriting.sendFunds.ach.estimatedActivity.maximumTransactionAmount",
+    UnderwritingSendFundsAchEstimatedActivityMonthlyVolumeRange: "underwriting.sendFunds.ach.estimatedActivity.monthlyVolumeRange",
+    UnderwritingSendFundsAchFulfillment: "underwriting.sendFunds.ach.fulfillment",
+    UnderwritingSendFundsAchRefundPolicy: "underwriting.sendFunds.ach.refundPolicy",
+    UnderwritingSendFundsRtpCardAcceptanceMethods: "underwriting.sendFunds.rtp.cardAcceptanceMethods",
+    UnderwritingSendFundsRtpCurrentlyAcceptsCards: "underwriting.sendFunds.rtp.currentlyAcceptsCards",
+    UnderwritingSendFundsRtpEstimatedActivityAverageTransactionAmount: "underwriting.sendFunds.rtp.estimatedActivity.averageTransactionAmount",
+    UnderwritingSendFundsRtpEstimatedActivityMaximumTransactionAmount: "underwriting.sendFunds.rtp.estimatedActivity.maximumTransactionAmount",
+    UnderwritingSendFundsRtpEstimatedActivityMonthlyVolumeRange: "underwriting.sendFunds.rtp.estimatedActivity.monthlyVolumeRange",
+    UnderwritingSendFundsRtpFulfillment: "underwriting.sendFunds.rtp.fulfillment",
+    UnderwritingSendFundsRtpRefundPolicy: "underwriting.sendFunds.rtp.refundPolicy",
+    UnderwritingSendFundsPushToCardCardAcceptanceMethods: "underwriting.sendFunds.pushToCard.cardAcceptanceMethods",
+    UnderwritingSendFundsPushToCardCurrentlyAcceptsCards: "underwriting.sendFunds.pushToCard.currentlyAcceptsCards",
+    UnderwritingSendFundsPushToCardEstimatedActivityAverageTransactionAmount: "underwriting.sendFunds.pushToCard.estimatedActivity.averageTransactionAmount",
+    UnderwritingSendFundsPushToCardEstimatedActivityMaximumTransactionAmount: "underwriting.sendFunds.pushToCard.estimatedActivity.maximumTransactionAmount",
+    UnderwritingSendFundsPushToCardEstimatedActivityMonthlyVolumeRange: "underwriting.sendFunds.pushToCard.estimatedActivity.monthlyVolumeRange",
+    UnderwritingSendFundsPushToCardFulfillment: "underwriting.sendFunds.pushToCard.fulfillment",
+    UnderwritingSendFundsPushToCardRefundPolicy: "underwriting.sendFunds.pushToCard.refundPolicy",
+    UnderwritingMoneyTransferPullFromCardCardAcceptanceMethods: "underwriting.moneyTransfer.pullFromCard.cardAcceptanceMethods",
+    UnderwritingMoneyTransferPullFromCardCurrentlyAcceptsCards: "underwriting.moneyTransfer.pullFromCard.currentlyAcceptsCards",
+    UnderwritingMoneyTransferPullFromCardEstimatedActivityAverageTransactionAmount: "underwriting.moneyTransfer.pullFromCard.estimatedActivity.averageTransactionAmount",
+    UnderwritingMoneyTransferPullFromCardEstimatedActivityMaximumTransactionAmount: "underwriting.moneyTransfer.pullFromCard.estimatedActivity.maximumTransactionAmount",
+    UnderwritingMoneyTransferPullFromCardEstimatedActivityMonthlyVolumeRange: "underwriting.moneyTransfer.pullFromCard.estimatedActivity.monthlyVolumeRange",
+    UnderwritingMoneyTransferPullFromCardFulfillment: "underwriting.moneyTransfer.pullFromCard.fulfillment",
+    UnderwritingMoneyTransferPullFromCardRefundPolicy: "underwriting.moneyTransfer.pullFromCard.refundPolicy",
+    UnderwritingMoneyTransferPushToCardCardAcceptanceMethods: "underwriting.moneyTransfer.pushToCard.cardAcceptanceMethods",
+    UnderwritingMoneyTransferPushToCardCurrentlyAcceptsCards: "underwriting.moneyTransfer.pushToCard.currentlyAcceptsCards",
+    UnderwritingMoneyTransferPushToCardEstimatedActivityAverageTransactionAmount: "underwriting.moneyTransfer.pushToCard.estimatedActivity.averageTransactionAmount",
+    UnderwritingMoneyTransferPushToCardEstimatedActivityMaximumTransactionAmount: "underwriting.moneyTransfer.pushToCard.estimatedActivity.maximumTransactionAmount",
+    UnderwritingMoneyTransferPushToCardEstimatedActivityMonthlyVolumeRange: "underwriting.moneyTransfer.pushToCard.estimatedActivity.monthlyVolumeRange",
+    UnderwritingMoneyTransferPushToCardFulfillment: "underwriting.moneyTransfer.pushToCard.fulfillment",
+    UnderwritingMoneyTransferPushToCardRefundPolicy: "underwriting.moneyTransfer.pushToCard.refundPolicy"
   };
   RequirementID$inboundSchema = nativeEnumType(RequirementID);
   RequirementID$outboundSchema = RequirementID$inboundSchema;
@@ -59133,6 +59237,38 @@ var init_card = __esm(() => {
   });
 });
 
+// src/models/components/cardacceptancemethods.ts
+var CardAcceptanceMethods$inboundSchema, CardAcceptanceMethods$outboundSchema;
+var init_cardacceptancemethods = __esm(() => {
+  init_esm();
+  CardAcceptanceMethods$inboundSchema = objectType({
+    inPersonPercentage: numberType().int().optional(),
+    mailOrPhonePercentage: numberType().int().optional(),
+    onlinePercentage: numberType().int().optional()
+  });
+  CardAcceptanceMethods$outboundSchema = objectType({
+    inPersonPercentage: numberType().int().optional(),
+    mailOrPhonePercentage: numberType().int().optional(),
+    onlinePercentage: numberType().int().optional()
+  });
+});
+
+// src/models/components/cardacceptancemethodserror.ts
+var CardAcceptanceMethodsError$inboundSchema, CardAcceptanceMethodsError$outboundSchema;
+var init_cardacceptancemethodserror = __esm(() => {
+  init_esm();
+  CardAcceptanceMethodsError$inboundSchema = objectType({
+    inPersonPercentage: stringType().optional(),
+    mailOrPhonePercentage: stringType().optional(),
+    onlinePercentage: stringType().optional()
+  });
+  CardAcceptanceMethodsError$outboundSchema = objectType({
+    inPersonPercentage: stringType().optional(),
+    mailOrPhonePercentage: stringType().optional(),
+    onlinePercentage: stringType().optional()
+  });
+});
+
 // src/models/components/cardacquiringdispute.ts
 var CardAcquiringDispute$inboundSchema, CardAcquiringDispute$outboundSchema;
 var init_cardacquiringdispute = __esm(() => {
@@ -59448,6 +59584,72 @@ var init_cardpaymentpaymentmethod = __esm(() => {
   });
 });
 
+// src/models/components/entrymode.ts
+var EntryMode, EntryMode$inboundSchema, EntryMode$outboundSchema;
+var init_entrymode = __esm(() => {
+  init_esm();
+  EntryMode = {
+    Contactless: "contactless"
+  };
+  EntryMode$inboundSchema = nativeEnumType(EntryMode);
+  EntryMode$outboundSchema = EntryMode$inboundSchema;
+});
+
+// src/models/components/terminalcard.ts
+var TerminalCard$inboundSchema, TerminalCard$outboundSchema;
+var init_terminalcard = __esm(() => {
+  init_esm();
+  init_cardbrand();
+  init_cardexpiration();
+  init_cardtype();
+  init_entrymode();
+  TerminalCard$inboundSchema = objectType({
+    entryMode: EntryMode$inboundSchema.optional(),
+    brand: CardBrand$inboundSchema.optional(),
+    bin: stringType().optional(),
+    cardType: CardType$inboundSchema.optional(),
+    expiration: CardExpiration$inboundSchema.optional(),
+    fingerprint: stringType().optional(),
+    holderName: stringType().optional(),
+    issuer: stringType().optional(),
+    issuerCountry: stringType().optional(),
+    lastFourCardNumber: stringType().optional(),
+    applicationID: stringType().optional(),
+    applicationName: stringType().optional()
+  });
+  TerminalCard$outboundSchema = objectType({
+    entryMode: EntryMode$outboundSchema.optional(),
+    brand: CardBrand$outboundSchema.optional(),
+    bin: stringType().optional(),
+    cardType: CardType$outboundSchema.optional(),
+    expiration: CardExpiration$outboundSchema.optional(),
+    fingerprint: stringType().optional(),
+    holderName: stringType().optional(),
+    issuer: stringType().optional(),
+    issuerCountry: stringType().optional(),
+    lastFourCardNumber: stringType().optional(),
+    applicationID: stringType().optional(),
+    applicationName: stringType().optional()
+  });
+});
+
+// src/models/components/cardpresentpaymentpaymentmethod.ts
+var CardPresentPaymentPaymentMethod$inboundSchema, CardPresentPaymentPaymentMethod$outboundSchema;
+var init_cardpresentpaymentpaymentmethod = __esm(() => {
+  init_esm();
+  init_terminalcard();
+  CardPresentPaymentPaymentMethod$inboundSchema = objectType({
+    paymentMethodID: stringType(),
+    paymentMethodType: literalType("card-present-payment"),
+    terminalCard: TerminalCard$inboundSchema.optional()
+  });
+  CardPresentPaymentPaymentMethod$outboundSchema = objectType({
+    paymentMethodID: stringType(),
+    paymentMethodType: literalType("card-present-payment"),
+    terminalCard: TerminalCard$outboundSchema.optional()
+  });
+});
+
 // src/models/components/cardtransactionstatus.ts
 var CardTransactionStatus, CardTransactionStatus$inboundSchema, CardTransactionStatus$outboundSchema;
 var init_cardtransactionstatus = __esm(() => {
@@ -59552,6 +59754,248 @@ var init_cardvolumedistributionerror = __esm(() => {
   });
 });
 
+// src/models/components/monthlyvolumerange.ts
+var MonthlyVolumeRange, MonthlyVolumeRange$inboundSchema, MonthlyVolumeRange$outboundSchema;
+var init_monthlyvolumerange = __esm(() => {
+  init_esm();
+  MonthlyVolumeRange = {
+    Under10k: "under-10k",
+    Tenk50k: "10k-50k",
+    Fiftyk100k: "50k-100k",
+    OneHundredk250k: "100k-250k",
+    TwoHundredAndFiftyk500k: "250k-500k",
+    FiveHundredk1m: "500k-1m",
+    Onem5m: "1m-5m",
+    Over5m: "over-5m"
+  };
+  MonthlyVolumeRange$inboundSchema = nativeEnumType(MonthlyVolumeRange);
+  MonthlyVolumeRange$outboundSchema = MonthlyVolumeRange$inboundSchema;
+});
+
+// src/models/components/estimatedactivity.ts
+var EstimatedActivity$inboundSchema, EstimatedActivity$outboundSchema;
+var init_estimatedactivity = __esm(() => {
+  init_esm();
+  init_monthlyvolumerange();
+  EstimatedActivity$inboundSchema = objectType({
+    averageTransactionAmount: numberType().int().optional(),
+    maximumTransactionAmount: numberType().int().optional(),
+    monthlyVolumeRange: MonthlyVolumeRange$inboundSchema.optional()
+  });
+  EstimatedActivity$outboundSchema = objectType({
+    averageTransactionAmount: numberType().int().optional(),
+    maximumTransactionAmount: numberType().int().optional(),
+    monthlyVolumeRange: MonthlyVolumeRange$outboundSchema.optional()
+  });
+});
+
+// src/models/components/collectfundsach.ts
+var CollectFundsAch$inboundSchema, CollectFundsAch$outboundSchema;
+var init_collectfundsach = __esm(() => {
+  init_esm();
+  init_estimatedactivity();
+  CollectFundsAch$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$inboundSchema.optional()
+  });
+  CollectFundsAch$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$outboundSchema.optional()
+  });
+});
+
+// src/models/components/fulfillmentmethod.ts
+var FulfillmentMethod, FulfillmentMethod$inboundSchema, FulfillmentMethod$outboundSchema;
+var init_fulfillmentmethod = __esm(() => {
+  init_esm();
+  FulfillmentMethod = {
+    BillOrDebtPayment: "bill-or-debt-payment",
+    DigitalContent: "digital-content",
+    Donation: "donation",
+    InPersonService: "in-person-service",
+    LocalPickupOrDelivery: "local-pickup-or-delivery",
+    Other: "other",
+    RemoteService: "remote-service",
+    ShippedPhysicalGoods: "shipped-physical-goods",
+    SubscriptionOrMembership: "subscription-or-membership"
+  };
+  FulfillmentMethod$inboundSchema = nativeEnumType(FulfillmentMethod);
+  FulfillmentMethod$outboundSchema = FulfillmentMethod$inboundSchema;
+});
+
+// src/models/components/fulfillmenttimeframe.ts
+var FulfillmentTimeframe, FulfillmentTimeframe$inboundSchema, FulfillmentTimeframe$outboundSchema;
+var init_fulfillmenttimeframe = __esm(() => {
+  init_esm();
+  FulfillmentTimeframe = {
+    Immediate: "immediate",
+    Other: "other",
+    Over30Days: "over-30-days",
+    PreOrder: "pre-order",
+    RecurringSchedule: "recurring-schedule",
+    ScheduledEvent: "scheduled-event",
+    Within30Days: "within-30-days",
+    Within7Days: "within-7-days"
+  };
+  FulfillmentTimeframe$inboundSchema = nativeEnumType(FulfillmentTimeframe);
+  FulfillmentTimeframe$outboundSchema = FulfillmentTimeframe$inboundSchema;
+});
+
+// src/models/components/fulfillment.ts
+var Fulfillment$inboundSchema, Fulfillment$outboundSchema;
+var init_fulfillment = __esm(() => {
+  init_esm();
+  init_fulfillmentmethod();
+  init_fulfillmenttimeframe();
+  Fulfillment$inboundSchema = objectType({
+    method: FulfillmentMethod$inboundSchema.optional(),
+    timeframe: FulfillmentTimeframe$inboundSchema.optional()
+  });
+  Fulfillment$outboundSchema = objectType({
+    method: FulfillmentMethod$outboundSchema.optional(),
+    timeframe: FulfillmentTimeframe$outboundSchema.optional()
+  });
+});
+
+// src/models/components/refundpolicy.ts
+var RefundPolicy, RefundPolicy$inboundSchema, RefundPolicy$outboundSchema;
+var init_refundpolicy = __esm(() => {
+  init_esm();
+  RefundPolicy = {
+    ConditionalRefund: "conditional-refund",
+    CustomPolicy: "custom-policy",
+    EventBasedPolicy: "event-based-policy",
+    FullRefundExtendedWindow: "full-refund-extended-window",
+    FullRefundWithin30Days: "full-refund-within-30-days",
+    NoRefunds: "no-refunds",
+    PartialRefund: "partial-refund",
+    ProratedRefund: "prorated-refund",
+    StoreCreditOnly: "store-credit-only"
+  };
+  RefundPolicy$inboundSchema = nativeEnumType(RefundPolicy);
+  RefundPolicy$outboundSchema = RefundPolicy$inboundSchema;
+});
+
+// src/models/components/collectfundscardpayments.ts
+var CollectFundsCardPayments$inboundSchema, CollectFundsCardPayments$outboundSchema;
+var init_collectfundscardpayments = __esm(() => {
+  init_esm();
+  init_cardacceptancemethods();
+  init_estimatedactivity();
+  init_fulfillment();
+  init_refundpolicy();
+  CollectFundsCardPayments$inboundSchema = objectType({
+    cardAcceptanceMethods: CardAcceptanceMethods$inboundSchema.optional(),
+    currentlyAcceptsCards: booleanType().optional(),
+    estimatedActivity: EstimatedActivity$inboundSchema.optional(),
+    fulfillment: Fulfillment$inboundSchema.optional(),
+    refundPolicy: RefundPolicy$inboundSchema.optional()
+  });
+  CollectFundsCardPayments$outboundSchema = objectType({
+    cardAcceptanceMethods: CardAcceptanceMethods$outboundSchema.optional(),
+    currentlyAcceptsCards: booleanType().optional(),
+    estimatedActivity: EstimatedActivity$outboundSchema.optional(),
+    fulfillment: Fulfillment$outboundSchema.optional(),
+    refundPolicy: RefundPolicy$outboundSchema.optional()
+  });
+});
+
+// src/models/components/collectfunds.ts
+var CollectFunds$inboundSchema, CollectFunds$outboundSchema;
+var init_collectfunds = __esm(() => {
+  init_esm();
+  init_collectfundsach();
+  init_collectfundscardpayments();
+  CollectFunds$inboundSchema = objectType({
+    ach: CollectFundsAch$inboundSchema.optional(),
+    cardPayments: CollectFundsCardPayments$inboundSchema.optional()
+  });
+  CollectFunds$outboundSchema = objectType({
+    ach: CollectFundsAch$outboundSchema.optional(),
+    cardPayments: CollectFundsCardPayments$outboundSchema.optional()
+  });
+});
+
+// src/models/components/estimatedactivityerror.ts
+var EstimatedActivityError$inboundSchema, EstimatedActivityError$outboundSchema;
+var init_estimatedactivityerror = __esm(() => {
+  init_esm();
+  EstimatedActivityError$inboundSchema = objectType({
+    averageTransactionAmount: stringType().optional(),
+    maximumTransactionAmount: stringType().optional(),
+    monthlyVolumeRange: stringType().optional()
+  });
+  EstimatedActivityError$outboundSchema = objectType({
+    averageTransactionAmount: stringType().optional(),
+    maximumTransactionAmount: stringType().optional(),
+    monthlyVolumeRange: stringType().optional()
+  });
+});
+
+// src/models/components/collectfundsacherror.ts
+var CollectFundsAchError$inboundSchema, CollectFundsAchError$outboundSchema;
+var init_collectfundsacherror = __esm(() => {
+  init_esm();
+  init_estimatedactivityerror();
+  CollectFundsAchError$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$inboundSchema.optional()
+  });
+  CollectFundsAchError$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$outboundSchema.optional()
+  });
+});
+
+// src/models/components/fulfillmenterror.ts
+var FulfillmentError$inboundSchema, FulfillmentError$outboundSchema;
+var init_fulfillmenterror = __esm(() => {
+  init_esm();
+  FulfillmentError$inboundSchema = objectType({
+    method: stringType().optional(),
+    timeframe: stringType().optional()
+  });
+  FulfillmentError$outboundSchema = objectType({
+    method: stringType().optional(),
+    timeframe: stringType().optional()
+  });
+});
+
+// src/models/components/collectfundscardpaymentserror.ts
+var CollectFundsCardPaymentsError$inboundSchema, CollectFundsCardPaymentsError$outboundSchema;
+var init_collectfundscardpaymentserror = __esm(() => {
+  init_esm();
+  init_cardacceptancemethodserror();
+  init_estimatedactivityerror();
+  init_fulfillmenterror();
+  CollectFundsCardPaymentsError$inboundSchema = objectType({
+    cardAcceptanceMethods: CardAcceptanceMethodsError$inboundSchema.optional(),
+    currentlyAcceptsCards: stringType().optional(),
+    estimatedActivity: EstimatedActivityError$inboundSchema.optional(),
+    fulfillment: FulfillmentError$inboundSchema.optional(),
+    refundPolicy: stringType().optional()
+  });
+  CollectFundsCardPaymentsError$outboundSchema = objectType({
+    cardAcceptanceMethods: CardAcceptanceMethodsError$outboundSchema.optional(),
+    currentlyAcceptsCards: stringType().optional(),
+    estimatedActivity: EstimatedActivityError$outboundSchema.optional(),
+    fulfillment: FulfillmentError$outboundSchema.optional(),
+    refundPolicy: stringType().optional()
+  });
+});
+
+// src/models/components/collectfundserror.ts
+var CollectFundsError$inboundSchema, CollectFundsError$outboundSchema;
+var init_collectfundserror = __esm(() => {
+  init_esm();
+  init_collectfundsacherror();
+  init_collectfundscardpaymentserror();
+  CollectFundsError$inboundSchema = objectType({
+    ach: CollectFundsAchError$inboundSchema.optional(),
+    cardPayments: CollectFundsCardPaymentsError$inboundSchema.optional()
+  });
+  CollectFundsError$outboundSchema = objectType({
+    ach: CollectFundsAchError$outboundSchema.optional(),
+    cardPayments: CollectFundsCardPaymentsError$outboundSchema.optional()
+  });
+});
+
 // src/models/components/collectionpaymentmethodtype.ts
 var CollectionPaymentMethodType, CollectionPaymentMethodType$inboundSchema, CollectionPaymentMethodType$outboundSchema;
 var init_collectionpaymentmethodtype = __esm(() => {
@@ -59628,6 +60072,18 @@ var init_completemicrodeposits = __esm(() => {
   });
 });
 
+// src/models/components/createaccounttype.ts
+var CreateAccountType, CreateAccountType$inboundSchema, CreateAccountType$outboundSchema;
+var init_createaccounttype = __esm(() => {
+  init_esm();
+  CreateAccountType = {
+    Individual: "individual",
+    Business: "business"
+  };
+  CreateAccountType$inboundSchema = nativeEnumType(CreateAccountType);
+  CreateAccountType$outboundSchema = CreateAccountType$inboundSchema;
+});
+
 // src/models/components/taxid.ts
 var Ein$inboundSchema, Ein$outboundSchema, TaxID$inboundSchema, TaxID$outboundSchema;
 var init_taxid = __esm(() => {
@@ -59796,15 +60252,15 @@ var init_termsofservicepayload = __esm(() => {
 var CreateAccount$inboundSchema, CreateAccount$outboundSchema;
 var init_createaccount = __esm(() => {
   init_esm();
-  init_accounttype();
   init_capabilityid();
+  init_createaccounttype();
   init_createprofile();
   init_customersupport();
   init_mode();
   init_settings();
   init_termsofservicepayload();
   CreateAccount$inboundSchema = objectType({
-    accountType: AccountType$inboundSchema,
+    accountType: CreateAccountType$inboundSchema,
     profile: CreateProfile$inboundSchema,
     metadata: recordType(stringType()).optional(),
     termsOfService: TermsOfServicePayload$inboundSchema.optional(),
@@ -59815,7 +60271,7 @@ var init_createaccount = __esm(() => {
     mode: Mode$inboundSchema.optional()
   });
   CreateAccount$outboundSchema = objectType({
-    accountType: AccountType$outboundSchema,
+    accountType: CreateAccountType$outboundSchema,
     profile: CreateProfile$outboundSchema,
     metadata: recordType(stringType()).optional(),
     termsOfService: TermsOfServicePayload$outboundSchema.optional(),
@@ -60274,6 +60730,7 @@ var init_transfersource = __esm(() => {
   init_paymentmethodscard();
   init_paymentmethodswallet();
   init_paymentmethodtype();
+  init_terminalcard();
   init_transferaccount();
   TransferSource$inboundSchema = objectType({
     transferID: stringType().optional(),
@@ -60284,6 +60741,7 @@ var init_transfersource = __esm(() => {
     wallet: PaymentMethodsWallet$inboundSchema.optional(),
     card: PaymentMethodsCard$inboundSchema.optional(),
     applePay: ApplePayResponse$inboundSchema.optional(),
+    terminalCard: TerminalCard$inboundSchema.optional(),
     cardDetails: CardTransactionDetails$inboundSchema.optional(),
     achDetails: ACHTransactionDetails$inboundSchema.optional()
   });
@@ -60296,6 +60754,7 @@ var init_transfersource = __esm(() => {
     wallet: PaymentMethodsWallet$outboundSchema.optional(),
     card: PaymentMethodsCard$outboundSchema.optional(),
     applePay: ApplePayResponse$outboundSchema.optional(),
+    terminalCard: TerminalCard$outboundSchema.optional(),
     cardDetails: CardTransactionDetails$outboundSchema.optional(),
     achDetails: ACHTransactionDetails$outboundSchema.optional()
   });
@@ -61141,6 +61600,55 @@ var init_createterminalapplication = __esm(() => {
   });
 });
 
+// src/models/components/ticketcontact.ts
+var TicketContact$inboundSchema, TicketContact$outboundSchema;
+var init_ticketcontact = __esm(() => {
+  init_esm();
+  TicketContact$inboundSchema = objectType({
+    email: stringType(),
+    name: stringType().optional()
+  });
+  TicketContact$outboundSchema = objectType({
+    email: stringType(),
+    name: stringType().optional()
+  });
+});
+
+// src/models/components/createticket.ts
+var CreateTicket$inboundSchema, CreateTicket$outboundSchema;
+var init_createticket = __esm(() => {
+  init_esm();
+  init_ticketcontact();
+  CreateTicket$inboundSchema = objectType({
+    title: stringType(),
+    body: stringType(),
+    author: stringType().optional(),
+    contact: TicketContact$inboundSchema,
+    foreignID: stringType().optional()
+  });
+  CreateTicket$outboundSchema = objectType({
+    title: stringType(),
+    body: stringType(),
+    author: stringType().optional(),
+    contact: TicketContact$outboundSchema,
+    foreignID: stringType().optional()
+  });
+});
+
+// src/models/components/createticketcontacterror.ts
+var CreateTicketContactError$inboundSchema, CreateTicketContactError$outboundSchema;
+var init_createticketcontacterror = __esm(() => {
+  init_esm();
+  CreateTicketContactError$inboundSchema = objectType({
+    email: stringType().optional(),
+    name: stringType().optional()
+  });
+  CreateTicketContactError$outboundSchema = objectType({
+    email: stringType().optional(),
+    name: stringType().optional()
+  });
+});
+
 // src/models/components/createtransferachaddendarecord.ts
 var CreateTransferACHAddendaRecord$inboundSchema, CreateTransferACHAddendaRecord$outboundSchema;
 var init_createtransferachaddendarecord = __esm(() => {
@@ -61785,21 +62293,23 @@ var init_enrichedbusinessresponse = __esm(() => {
   });
 });
 
-// src/models/components/enrichedindustry.ts
-var EnrichedIndustry$inboundSchema, EnrichedIndustry$outboundSchema;
-var init_enrichedindustry = __esm(() => {
+// src/models/components/industrytaxonomy.ts
+var IndustryTaxonomy$inboundSchema, IndustryTaxonomy$outboundSchema;
+var init_industrytaxonomy = __esm(() => {
   init_esm();
-  EnrichedIndustry$inboundSchema = objectType({
-    title: stringType(),
-    naics: stringType(),
-    sic: stringType(),
-    mcc: stringType()
+  IndustryTaxonomy$inboundSchema = objectType({
+    industry: stringType(),
+    displayName: stringType(),
+    category: stringType(),
+    categoryDisplayName: stringType(),
+    defaultMcc: stringType()
   });
-  EnrichedIndustry$outboundSchema = objectType({
-    title: stringType(),
-    naics: stringType(),
-    sic: stringType(),
-    mcc: stringType()
+  IndustryTaxonomy$outboundSchema = objectType({
+    industry: stringType(),
+    displayName: stringType(),
+    category: stringType(),
+    categoryDisplayName: stringType(),
+    defaultMcc: stringType()
   });
 });
 
@@ -61807,12 +62317,12 @@ var init_enrichedindustry = __esm(() => {
 var EnrichedIndustries$inboundSchema, EnrichedIndustries$outboundSchema;
 var init_enrichedindustries = __esm(() => {
   init_esm();
-  init_enrichedindustry();
+  init_industrytaxonomy();
   EnrichedIndustries$inboundSchema = objectType({
-    industries: arrayType(EnrichedIndustry$inboundSchema)
+    industries: arrayType(IndustryTaxonomy$inboundSchema)
   });
   EnrichedIndustries$outboundSchema = objectType({
-    industries: arrayType(EnrichedIndustry$outboundSchema)
+    industries: arrayType(IndustryTaxonomy$outboundSchema)
   });
 });
 
@@ -62303,6 +62813,19 @@ var init_generatedby = __esm(() => {
   });
 });
 
+// src/models/components/geographicreach.ts
+var GeographicReach, GeographicReach$inboundSchema, GeographicReach$outboundSchema;
+var init_geographicreach = __esm(() => {
+  init_esm();
+  GeographicReach = {
+    InternationalOnly: "international-only",
+    UsAndInternational: "us-and-international",
+    UsOnly: "us-only"
+  };
+  GeographicReach$inboundSchema = nativeEnumType(GeographicReach);
+  GeographicReach$outboundSchema = GeographicReach$inboundSchema;
+});
+
 // src/models/components/governmentiderror.ts
 var GovernmentIDErrorSsn$inboundSchema, GovernmentIDErrorSsn$outboundSchema, GovernmentIDErrorItin$inboundSchema, GovernmentIDErrorItin$outboundSchema, GovernmentIDError$inboundSchema, GovernmentIDError$outboundSchema;
 var init_governmentiderror = __esm(() => {
@@ -62810,6 +63333,18 @@ var init_issuingcontrolserror = __esm(() => {
   });
 });
 
+// src/models/components/itemlistnextpage.ts
+var ItemListNextPage$inboundSchema, ItemListNextPage$outboundSchema;
+var init_itemlistnextpage = __esm(() => {
+  init_esm();
+  ItemListNextPage$inboundSchema = objectType({
+    cursor: stringType()
+  });
+  ItemListNextPage$outboundSchema = objectType({
+    cursor: stringType()
+  });
+});
+
 // src/models/components/jsonwebkey.ts
 var Use, Use$inboundSchema, Use$outboundSchema, JSONWebKey$inboundSchema, JSONWebKey$outboundSchema;
 var init_jsonwebkey = __esm(() => {
@@ -63123,6 +63658,90 @@ var init_manualtermsofserviceupdate = __esm(() => {
   });
 });
 
+// src/models/components/moneytransferpullfromcard.ts
+var MoneyTransferPullFromCard$inboundSchema, MoneyTransferPullFromCard$outboundSchema;
+var init_moneytransferpullfromcard = __esm(() => {
+  init_esm();
+  init_estimatedactivity();
+  MoneyTransferPullFromCard$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$inboundSchema.optional()
+  });
+  MoneyTransferPullFromCard$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$outboundSchema.optional()
+  });
+});
+
+// src/models/components/moneytransferpushtocard.ts
+var MoneyTransferPushToCard$inboundSchema, MoneyTransferPushToCard$outboundSchema;
+var init_moneytransferpushtocard = __esm(() => {
+  init_esm();
+  init_estimatedactivity();
+  MoneyTransferPushToCard$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$inboundSchema.optional()
+  });
+  MoneyTransferPushToCard$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$outboundSchema.optional()
+  });
+});
+
+// src/models/components/moneytransfer.ts
+var MoneyTransfer$inboundSchema, MoneyTransfer$outboundSchema;
+var init_moneytransfer = __esm(() => {
+  init_esm();
+  init_moneytransferpullfromcard();
+  init_moneytransferpushtocard();
+  MoneyTransfer$inboundSchema = objectType({
+    pullFromCard: MoneyTransferPullFromCard$inboundSchema.optional(),
+    pushToCard: MoneyTransferPushToCard$inboundSchema.optional()
+  });
+  MoneyTransfer$outboundSchema = objectType({
+    pullFromCard: MoneyTransferPullFromCard$outboundSchema.optional(),
+    pushToCard: MoneyTransferPushToCard$outboundSchema.optional()
+  });
+});
+
+// src/models/components/moneytransferpullfromcarderror.ts
+var MoneyTransferPullFromCardError$inboundSchema, MoneyTransferPullFromCardError$outboundSchema;
+var init_moneytransferpullfromcarderror = __esm(() => {
+  init_esm();
+  init_estimatedactivityerror();
+  MoneyTransferPullFromCardError$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$inboundSchema.optional()
+  });
+  MoneyTransferPullFromCardError$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$outboundSchema.optional()
+  });
+});
+
+// src/models/components/moneytransferpushtocarderror.ts
+var MoneyTransferPushToCardError$inboundSchema, MoneyTransferPushToCardError$outboundSchema;
+var init_moneytransferpushtocarderror = __esm(() => {
+  init_esm();
+  init_estimatedactivityerror();
+  MoneyTransferPushToCardError$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$inboundSchema.optional()
+  });
+  MoneyTransferPushToCardError$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$outboundSchema.optional()
+  });
+});
+
+// src/models/components/moneytransfererror.ts
+var MoneyTransferError$inboundSchema, MoneyTransferError$outboundSchema;
+var init_moneytransfererror = __esm(() => {
+  init_esm();
+  init_moneytransferpullfromcarderror();
+  init_moneytransferpushtocarderror();
+  MoneyTransferError$inboundSchema = objectType({
+    pullFromCard: MoneyTransferPullFromCardError$inboundSchema.optional(),
+    pushToCard: MoneyTransferPushToCardError$inboundSchema.optional()
+  });
+  MoneyTransferError$outboundSchema = objectType({
+    pullFromCard: MoneyTransferPullFromCardError$outboundSchema.optional(),
+    pushToCard: MoneyTransferPushToCardError$outboundSchema.optional()
+  });
+});
+
 // src/models/components/transferparty.ts
 var TransferParty, TransferParty$inboundSchema, TransferParty$outboundSchema;
 var init_transferparty = __esm(() => {
@@ -64049,6 +64668,7 @@ var init_paymentmethod = __esm(() => {
   init_achdebitfundpaymentmethod();
   init_applepaypaymentmethod();
   init_cardpaymentpaymentmethod();
+  init_cardpresentpaymentpaymentmethod();
   init_moovwalletpaymentmethod();
   init_pullfromcardpaymentmethod();
   init_pushtocardpaymentmethod();
@@ -64063,7 +64683,8 @@ var init_paymentmethod = __esm(() => {
     CardPaymentPaymentMethod$inboundSchema,
     PushToCardPaymentMethod$inboundSchema,
     PullFromCardPaymentMethod$inboundSchema,
-    ApplePayPaymentMethod$inboundSchema
+    ApplePayPaymentMethod$inboundSchema,
+    CardPresentPaymentPaymentMethod$inboundSchema
   ]);
   PaymentMethod$outboundSchema = unionType([
     MoovWalletPaymentMethod$outboundSchema,
@@ -64075,7 +64696,8 @@ var init_paymentmethod = __esm(() => {
     CardPaymentPaymentMethod$outboundSchema,
     PushToCardPaymentMethod$outboundSchema,
     PullFromCardPaymentMethod$outboundSchema,
-    ApplePayPaymentMethod$outboundSchema
+    ApplePayPaymentMethod$outboundSchema,
+    CardPresentPaymentPaymentMethod$outboundSchema
   ]);
 });
 
@@ -64111,6 +64733,26 @@ var init_payoutdetailserror = __esm(() => {
   });
 });
 
+// src/models/components/pendinglitigation.ts
+var PendingLitigation, PendingLitigation$inboundSchema, PendingLitigation$outboundSchema;
+var init_pendinglitigation = __esm(() => {
+  init_esm();
+  PendingLitigation = {
+    BankruptcyOrInsolvency: "bankruptcy-or-insolvency",
+    ConsumerProtectionOrClassAction: "consumer-protection-or-class-action",
+    DataBreachOrPrivacy: "data-breach-or-privacy",
+    EmploymentOrWorkplaceDisputes: "employment-or-workplace-disputes",
+    FraudOrFinancialCrime: "fraud-or-financial-crime",
+    GovernmentEnforcementOrInvestigation: "government-enforcement-or-investigation",
+    IntellectualProperty: "intellectual-property",
+    None: "none",
+    Other: "other",
+    PersonalInjuryOrMedical: "personal-injury-or-medical"
+  };
+  PendingLitigation$inboundSchema = nativeEnumType(PendingLitigation);
+  PendingLitigation$outboundSchema = PendingLitigation$inboundSchema;
+});
+
 // src/models/components/webhook.ts
 var Webhook$inboundSchema, Webhook$outboundSchema;
 var init_webhook = __esm(() => {
@@ -64728,6 +65370,154 @@ var init_security2 = __esm(() => {
   });
 });
 
+// src/models/components/sendfundsach.ts
+var SendFundsAch$inboundSchema, SendFundsAch$outboundSchema;
+var init_sendfundsach = __esm(() => {
+  init_esm();
+  init_estimatedactivity();
+  SendFundsAch$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$inboundSchema.optional()
+  });
+  SendFundsAch$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfundsinstantbank.ts
+var SendFundsInstantBank$inboundSchema, SendFundsInstantBank$outboundSchema;
+var init_sendfundsinstantbank = __esm(() => {
+  init_esm();
+  init_estimatedactivity();
+  SendFundsInstantBank$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$inboundSchema.optional()
+  });
+  SendFundsInstantBank$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfundspushtocard.ts
+var SendFundsPushToCard$inboundSchema, SendFundsPushToCard$outboundSchema;
+var init_sendfundspushtocard = __esm(() => {
+  init_esm();
+  init_estimatedactivity();
+  SendFundsPushToCard$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$inboundSchema.optional()
+  });
+  SendFundsPushToCard$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfundsrtp.ts
+var SendFundsRtp$inboundSchema, SendFundsRtp$outboundSchema;
+var init_sendfundsrtp = __esm(() => {
+  init_esm();
+  init_estimatedactivity();
+  SendFundsRtp$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$inboundSchema.optional()
+  });
+  SendFundsRtp$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivity$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfunds.ts
+var SendFunds$inboundSchema, SendFunds$outboundSchema;
+var init_sendfunds = __esm(() => {
+  init_esm();
+  init_sendfundsach();
+  init_sendfundsinstantbank();
+  init_sendfundspushtocard();
+  init_sendfundsrtp();
+  SendFunds$inboundSchema = objectType({
+    ach: SendFundsAch$inboundSchema.optional(),
+    pushToCard: SendFundsPushToCard$inboundSchema.optional(),
+    rtp: SendFundsRtp$inboundSchema.optional(),
+    instantBank: SendFundsInstantBank$inboundSchema.optional()
+  });
+  SendFunds$outboundSchema = objectType({
+    ach: SendFundsAch$outboundSchema.optional(),
+    pushToCard: SendFundsPushToCard$outboundSchema.optional(),
+    rtp: SendFundsRtp$outboundSchema.optional(),
+    instantBank: SendFundsInstantBank$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfundsacherror.ts
+var SendFundsAchError$inboundSchema, SendFundsAchError$outboundSchema;
+var init_sendfundsacherror = __esm(() => {
+  init_esm();
+  init_estimatedactivityerror();
+  SendFundsAchError$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$inboundSchema.optional()
+  });
+  SendFundsAchError$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfundsinstantbankerror.ts
+var SendFundsInstantBankError$inboundSchema, SendFundsInstantBankError$outboundSchema;
+var init_sendfundsinstantbankerror = __esm(() => {
+  init_esm();
+  init_estimatedactivityerror();
+  SendFundsInstantBankError$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$inboundSchema.optional()
+  });
+  SendFundsInstantBankError$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfundspushtocarderror.ts
+var SendFundsPushToCardError$inboundSchema, SendFundsPushToCardError$outboundSchema;
+var init_sendfundspushtocarderror = __esm(() => {
+  init_esm();
+  init_estimatedactivityerror();
+  SendFundsPushToCardError$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$inboundSchema.optional()
+  });
+  SendFundsPushToCardError$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfundsrtperror.ts
+var SendFundsRtpError$inboundSchema, SendFundsRtpError$outboundSchema;
+var init_sendfundsrtperror = __esm(() => {
+  init_esm();
+  init_estimatedactivityerror();
+  SendFundsRtpError$inboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$inboundSchema.optional()
+  });
+  SendFundsRtpError$outboundSchema = objectType({
+    estimatedActivity: EstimatedActivityError$outboundSchema.optional()
+  });
+});
+
+// src/models/components/sendfundserror.ts
+var SendFundsError$inboundSchema, SendFundsError$outboundSchema;
+var init_sendfundserror = __esm(() => {
+  init_esm();
+  init_sendfundsacherror();
+  init_sendfundsinstantbankerror();
+  init_sendfundspushtocarderror();
+  init_sendfundsrtperror();
+  SendFundsError$inboundSchema = objectType({
+    ach: SendFundsAchError$inboundSchema.optional(),
+    pushToCard: SendFundsPushToCardError$inboundSchema.optional(),
+    rtp: SendFundsRtpError$inboundSchema.optional(),
+    instantBank: SendFundsInstantBankError$inboundSchema.optional()
+  });
+  SendFundsError$outboundSchema = objectType({
+    ach: SendFundsAchError$outboundSchema.optional(),
+    pushToCard: SendFundsPushToCardError$outboundSchema.optional(),
+    rtp: SendFundsRtpError$outboundSchema.optional(),
+    instantBank: SendFundsInstantBankError$outboundSchema.optional()
+  });
+});
+
 // src/models/components/sharescopes.ts
 var ShareScopes$inboundSchema, ShareScopes$outboundSchema;
 var init_sharescopes = __esm(() => {
@@ -64795,6 +65585,18 @@ var init_statement = __esm(() => {
   });
 });
 
+// src/models/components/submissionintent.ts
+var SubmissionIntent, SubmissionIntent$inboundSchema, SubmissionIntent$outboundSchema;
+var init_submissionintent = __esm(() => {
+  init_esm();
+  SubmissionIntent = {
+    Wait: "wait",
+    Submit: "submit"
+  };
+  SubmissionIntent$inboundSchema = nativeEnumType(SubmissionIntent);
+  SubmissionIntent$outboundSchema = SubmissionIntent$inboundSchema;
+});
+
 // src/models/components/sweepstatus.ts
 var SweepStatus, SweepStatus$inboundSchema, SweepStatus$outboundSchema;
 var init_sweepstatus = __esm(() => {
@@ -65066,6 +65868,54 @@ var init_ticketstatus = __esm(() => {
   TicketStatus$outboundSchema = TicketStatus$inboundSchema;
 });
 
+// src/models/components/ticket.ts
+var Ticket$inboundSchema, Ticket$outboundSchema;
+var init_ticket = __esm(() => {
+  init_esm();
+  init_ticketcontact();
+  init_ticketstatus();
+  Ticket$inboundSchema = objectType({
+    ticketID: stringType(),
+    number: numberType().int(),
+    title: stringType(),
+    contact: TicketContact$inboundSchema,
+    status: TicketStatus$inboundSchema,
+    createdOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    updatedOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    latestMessageOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    closedOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
+    foreignID: stringType().optional()
+  });
+  Ticket$outboundSchema = objectType({
+    ticketID: stringType(),
+    number: numberType().int(),
+    title: stringType(),
+    contact: TicketContact$outboundSchema,
+    status: TicketStatus$outboundSchema,
+    createdOn: dateType().transform((v2) => v2.toISOString()),
+    updatedOn: dateType().transform((v2) => v2.toISOString()),
+    latestMessageOn: dateType().transform((v2) => v2.toISOString()).optional(),
+    closedOn: dateType().transform((v2) => v2.toISOString()).optional(),
+    foreignID: stringType().optional()
+  });
+});
+
+// src/models/components/ticketmessage.ts
+var TicketMessage$inboundSchema, TicketMessage$outboundSchema;
+var init_ticketmessage = __esm(() => {
+  init_esm();
+  TicketMessage$inboundSchema = objectType({
+    author: stringType(),
+    body: stringType(),
+    sentOn: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+  });
+  TicketMessage$outboundSchema = objectType({
+    author: stringType(),
+    body: stringType(),
+    sentOn: dateType().transform((v2) => v2.toISOString())
+  });
+});
+
 // src/models/components/transfer.ts
 var Transfer$inboundSchema, Transfer$outboundSchema;
 var init_transfer = __esm(() => {
@@ -65199,31 +66049,68 @@ var init_volumebycustomertype = __esm(() => {
   });
 });
 
+// src/models/components/volumesharebycustomertype.ts
+var VolumeShareByCustomerType$inboundSchema, VolumeShareByCustomerType$outboundSchema;
+var init_volumesharebycustomertype = __esm(() => {
+  init_esm();
+  VolumeShareByCustomerType$inboundSchema = objectType({
+    business: numberType().int().optional(),
+    consumer: numberType().int().optional(),
+    p2p: numberType().int().optional()
+  });
+  VolumeShareByCustomerType$outboundSchema = objectType({
+    business: numberType().int().optional(),
+    consumer: numberType().int().optional(),
+    p2p: numberType().int().optional()
+  });
+});
+
 // src/models/components/underwriting.ts
 var Underwriting$inboundSchema, Underwriting$outboundSchema;
 var init_underwriting = __esm(() => {
   init_esm();
+  init_businesspresence();
   init_cardvolumedistribution();
+  init_collectfunds();
   init_fulfillmentdetails();
+  init_geographicreach();
+  init_moneytransfer();
+  init_pendinglitigation();
+  init_sendfunds();
   init_underwritingstatus();
   init_volumebycustomertype();
+  init_volumesharebycustomertype();
   Underwriting$inboundSchema = objectType({
-    averageTransactionSize: numberType().int(),
-    maxTransactionSize: numberType().int(),
-    averageMonthlyTransactionVolume: numberType().int(),
-    status: UnderwritingStatus$inboundSchema,
-    volumeByCustomerType: VolumeByCustomerType$inboundSchema,
-    cardVolumeDistribution: CardVolumeDistribution$inboundSchema,
-    fulfillment: FulfillmentDetails$inboundSchema
+    averageTransactionSize: numberType().int().optional(),
+    maxTransactionSize: numberType().int().optional(),
+    averageMonthlyTransactionVolume: numberType().int().optional(),
+    status: UnderwritingStatus$inboundSchema.optional(),
+    volumeByCustomerType: VolumeByCustomerType$inboundSchema.optional(),
+    cardVolumeDistribution: CardVolumeDistribution$inboundSchema.optional(),
+    fulfillment: FulfillmentDetails$inboundSchema.optional(),
+    geographicReach: GeographicReach$inboundSchema.optional(),
+    businessPresence: BusinessPresence$inboundSchema.optional(),
+    pendingLitigation: PendingLitigation$inboundSchema.optional(),
+    volumeShareByCustomerType: VolumeShareByCustomerType$inboundSchema.optional(),
+    collectFunds: CollectFunds$inboundSchema.optional(),
+    moneyTransfer: MoneyTransfer$inboundSchema.optional(),
+    sendFunds: SendFunds$inboundSchema.optional()
   });
   Underwriting$outboundSchema = objectType({
-    averageTransactionSize: numberType().int(),
-    maxTransactionSize: numberType().int(),
-    averageMonthlyTransactionVolume: numberType().int(),
-    status: UnderwritingStatus$outboundSchema,
-    volumeByCustomerType: VolumeByCustomerType$outboundSchema,
-    cardVolumeDistribution: CardVolumeDistribution$outboundSchema,
-    fulfillment: FulfillmentDetails$outboundSchema
+    averageTransactionSize: numberType().int().optional(),
+    maxTransactionSize: numberType().int().optional(),
+    averageMonthlyTransactionVolume: numberType().int().optional(),
+    status: UnderwritingStatus$outboundSchema.optional(),
+    volumeByCustomerType: VolumeByCustomerType$outboundSchema.optional(),
+    cardVolumeDistribution: CardVolumeDistribution$outboundSchema.optional(),
+    fulfillment: FulfillmentDetails$outboundSchema.optional(),
+    geographicReach: GeographicReach$outboundSchema.optional(),
+    businessPresence: BusinessPresence$outboundSchema.optional(),
+    pendingLitigation: PendingLitigation$outboundSchema.optional(),
+    volumeShareByCustomerType: VolumeShareByCustomerType$outboundSchema.optional(),
+    collectFunds: CollectFunds$outboundSchema.optional(),
+    moneyTransfer: MoneyTransfer$outboundSchema.optional(),
+    sendFunds: SendFunds$outboundSchema.optional()
   });
 });
 
@@ -65477,6 +66364,30 @@ var init_updaterepresentative = __esm(() => {
   });
 });
 
+// src/models/components/updateticketstatus.ts
+var UpdateTicketStatus, UpdateTicketStatus$inboundSchema, UpdateTicketStatus$outboundSchema;
+var init_updateticketstatus = __esm(() => {
+  init_esm();
+  UpdateTicketStatus = {
+    Closed: "closed"
+  };
+  UpdateTicketStatus$inboundSchema = nativeEnumType(UpdateTicketStatus);
+  UpdateTicketStatus$outboundSchema = UpdateTicketStatus$inboundSchema;
+});
+
+// src/models/components/updateticket.ts
+var UpdateTicket$inboundSchema, UpdateTicket$outboundSchema;
+var init_updateticket = __esm(() => {
+  init_esm();
+  init_updateticketstatus();
+  UpdateTicket$inboundSchema = objectType({
+    status: UpdateTicketStatus$inboundSchema.optional()
+  });
+  UpdateTicket$outboundSchema = objectType({
+    status: UpdateTicketStatus$outboundSchema.optional()
+  });
+});
+
 // src/models/components/updateunderwriting.ts
 var UpdateUnderwriting$inboundSchema, UpdateUnderwriting$outboundSchema;
 var init_updateunderwriting = __esm(() => {
@@ -65540,6 +66451,40 @@ var init_upsertschedule = __esm(() => {
   });
 });
 
+// src/models/components/upsertunderwriting.ts
+var UpsertUnderwriting$inboundSchema, UpsertUnderwriting$outboundSchema;
+var init_upsertunderwriting = __esm(() => {
+  init_esm();
+  init_businesspresence();
+  init_collectfunds();
+  init_geographicreach();
+  init_moneytransfer();
+  init_pendinglitigation();
+  init_sendfunds();
+  init_submissionintent();
+  init_volumesharebycustomertype();
+  UpsertUnderwriting$inboundSchema = objectType({
+    geographicReach: GeographicReach$inboundSchema.optional(),
+    businessPresence: BusinessPresence$inboundSchema.optional(),
+    pendingLitigation: PendingLitigation$inboundSchema.optional(),
+    volumeShareByCustomerType: VolumeShareByCustomerType$inboundSchema.optional(),
+    collectFunds: CollectFunds$inboundSchema.optional(),
+    moneyTransfer: MoneyTransfer$inboundSchema.optional(),
+    sendFunds: SendFunds$inboundSchema.optional(),
+    submissionIntent: SubmissionIntent$inboundSchema.optional()
+  });
+  UpsertUnderwriting$outboundSchema = objectType({
+    geographicReach: GeographicReach$outboundSchema.optional(),
+    businessPresence: BusinessPresence$outboundSchema.optional(),
+    pendingLitigation: PendingLitigation$outboundSchema.optional(),
+    volumeShareByCustomerType: VolumeShareByCustomerType$outboundSchema.optional(),
+    collectFunds: CollectFunds$outboundSchema.optional(),
+    moneyTransfer: MoneyTransfer$outboundSchema.optional(),
+    sendFunds: SendFunds$outboundSchema.optional(),
+    submissionIntent: SubmissionIntent$outboundSchema.optional()
+  });
+});
+
 // src/models/components/volumebycustomertypeerror.ts
 var VolumeByCustomerTypeError$inboundSchema, VolumeByCustomerTypeError$outboundSchema;
 var init_volumebycustomertypeerror = __esm(() => {
@@ -65554,6 +66499,22 @@ var init_volumebycustomertypeerror = __esm(() => {
   });
 });
 
+// src/models/components/volumesharebycustomertypeerror.ts
+var VolumeShareByCustomerTypeError$inboundSchema, VolumeShareByCustomerTypeError$outboundSchema;
+var init_volumesharebycustomertypeerror = __esm(() => {
+  init_esm();
+  VolumeShareByCustomerTypeError$inboundSchema = objectType({
+    business: stringType().optional(),
+    consumer: stringType().optional(),
+    p2p: stringType().optional()
+  });
+  VolumeShareByCustomerTypeError$outboundSchema = objectType({
+    business: stringType().optional(),
+    consumer: stringType().optional(),
+    p2p: stringType().optional()
+  });
+});
+
 // src/models/components/walletavailablebalance.ts
 var WalletAvailableBalance$inboundSchema, WalletAvailableBalance$outboundSchema;
 var init_walletavailablebalance = __esm(() => {
@@ -66593,6 +67554,7 @@ var init_components = __esm(() => {
   init_brandcolors();
   init_brandcolorvalidationerror();
   init_brandproperties();
+  init_businesspresence();
   init_businessprofile();
   init_businesstype();
   init_calltoaction();
@@ -66603,6 +67565,8 @@ var init_components = __esm(() => {
   init_capabilityrequirement();
   init_capabilitystatus();
   init_card();
+  init_cardacceptancemethods();
+  init_cardacceptancemethodserror();
   init_cardaccountupdater();
   init_cardacquiringdispute();
   init_cardacquiringfees();
@@ -66618,6 +67582,7 @@ var init_components = __esm(() => {
   init_cardpaymentdetailserror();
   init_cardpaymentpaymentmethod();
   init_cardpaymentsettings();
+  init_cardpresentpaymentpaymentmethod();
   init_cardtransactiondetails();
   init_cardtransactionfailurecode();
   init_cardtransactionstatus();
@@ -66627,6 +67592,12 @@ var init_components = __esm(() => {
   init_cardverificationresult();
   init_cardvolumedistribution();
   init_cardvolumedistributionerror();
+  init_collectfunds();
+  init_collectfundsach();
+  init_collectfundsacherror();
+  init_collectfundscardpayments();
+  init_collectfundscardpaymentserror();
+  init_collectfundserror();
   init_collectionpaymentmethodtype();
   init_colorsvalidationerror();
   init_completebankaccountverification();
@@ -66635,6 +67606,7 @@ var init_components = __esm(() => {
   init_contact();
   init_createaccount();
   init_createaccountsettings();
+  init_createaccounttype();
   init_createapplepaysession();
   init_createauthorizeduser();
   init_createauthorizedusererror();
@@ -66669,6 +67641,8 @@ var init_components = __esm(() => {
   init_createscheduledtransferlineitems();
   init_createsweepconfig();
   init_createterminalapplication();
+  init_createticket();
+  init_createticketcontacterror();
   init_createtransfer();
   init_createtransferachaddendarecord();
   init_createtransferdestination();
@@ -66707,8 +67681,10 @@ var init_components = __esm(() => {
   init_enrichedbusinessprofile();
   init_enrichedbusinessresponse();
   init_enrichedindustries();
-  init_enrichedindustry();
   init_enrichedindustrycodes();
+  init_entrymode();
+  init_estimatedactivity();
+  init_estimatedactivityerror();
   init_eventtype();
   init_evidencetextresponse();
   init_evidencetype();
@@ -66727,13 +67703,19 @@ var init_components = __esm(() => {
   init_filestatus();
   init_fileuploadrequestmultipart();
   init_financialinstitutions();
+  init_fulfillment();
   init_fulfillmentdetails();
   init_fulfillmentdetailserror();
+  init_fulfillmenterror();
+  init_fulfillmentmethod();
+  init_fulfillmenttimeframe();
   init_fullissuedcard();
   init_generatedby();
+  init_geographicreach();
   init_governmentid();
   init_governmentiderror();
   init_granttype();
+  init_guestprofile();
   init_imagemetadata();
   init_imagemetadatarequest();
   init_imagemetadatavalidationerror();
@@ -66744,6 +67726,7 @@ var init_components = __esm(() => {
   init_individualnameupdate();
   init_individualprofile();
   init_industrycodes();
+  init_industrytaxonomy();
   init_instantpaymentfees();
   init_institutionssearchresponse();
   init_invoicestatus();
@@ -66762,6 +67745,7 @@ var init_components = __esm(() => {
   init_issuingmerchantdata();
   init_issuingvelocitylimit();
   init_issuingvelocitylimiterror();
+  init_itemlistnextpage();
   init_jsonwebkey();
   init_linkaccountterminalapplication();
   init_linkapplepay();
@@ -66778,7 +67762,14 @@ var init_components = __esm(() => {
   init_microdepositstatus();
   init_minimumcommitment();
   init_mode();
+  init_moneytransfer();
+  init_moneytransfererror();
+  init_moneytransferpullfromcard();
+  init_moneytransferpullfromcarderror();
+  init_moneytransferpushtocard();
+  init_moneytransferpushtocarderror();
   init_monthlyplatformfee();
+  init_monthlyvolumerange();
   init_moovfee();
   init_moovfeedetails();
   init_moovwalletpaymentmethod();
@@ -66824,6 +67815,7 @@ var init_components = __esm(() => {
   init_payoutdetailserror();
   init_payoutrecipient();
   init_payoutrecipienterror();
+  init_pendinglitigation();
   init_phonenumber();
   init_phonenumbererror();
   init_pingresponse();
@@ -66851,6 +67843,7 @@ var init_components = __esm(() => {
   init_recurresponse();
   init_refundcarddetails();
   init_refundcardstatus();
+  init_refundpolicy();
   init_refundstatus();
   init_registerapplepaymerchantdomains();
   init_representative();
@@ -66883,11 +67876,22 @@ var init_components = __esm(() => {
   init_scheduleresponse();
   init_seccode();
   init_security2();
+  init_sendfunds();
+  init_sendfundsach();
+  init_sendfundsacherror();
+  init_sendfundserror();
+  init_sendfundsinstantbank();
+  init_sendfundsinstantbankerror();
+  init_sendfundspushtocard();
+  init_sendfundspushtocarderror();
+  init_sendfundsrtp();
+  init_sendfundsrtperror();
   init_sentreceipt();
   init_settings();
   init_sharescopes();
   init_sourcedestinationoptions();
   init_statement();
+  init_submissionintent();
   init_sweep();
   init_sweepconfig();
   init_sweepconfigpaymentmethod();
@@ -66900,12 +67904,16 @@ var init_components = __esm(() => {
   init_terminalapplicationplatform();
   init_terminalapplicationstatus();
   init_terminalapplicationversion();
+  init_terminalcard();
   init_terminalconfiguration();
   init_termsofservice();
   init_termsofserviceerror();
   init_termsofservicepayload();
   init_termsofservicepayloadupdate();
   init_termsofservicetoken();
+  init_ticket();
+  init_ticketcontact();
+  init_ticketmessage();
   init_ticketstatus();
   init_tokentype();
   init_transactionsource();
@@ -66934,15 +67942,20 @@ var init_components = __esm(() => {
   init_updateissuedcardstate();
   init_updatepaymentlink();
   init_updaterepresentative();
+  init_updateticket();
+  init_updateticketstatus();
   init_updateunderwriting();
   init_updatewebhook();
   init_upsertschedule();
+  init_upsertunderwriting();
   init_verification();
   init_verificationstatus();
   init_verificationstatusdetail();
   init_volumebycustomertype();
   init_volumebycustomertypeerror();
   init_volumerange();
+  init_volumesharebycustomertype();
+  init_volumesharebycustomertypeerror();
   init_wallet();
   init_walletavailablebalance();
   init_walletstatus();
@@ -67344,6 +68357,58 @@ var init_createsweepconfigerror = __esm(() => {
   }));
 });
 
+// src/models/errors/createticketerror.ts
+var CreateTicketError, CreateTicketError$inboundSchema, CreateTicketError$outboundSchema;
+var init_createticketerror = __esm(() => {
+  init_esm();
+  init_components();
+  init_mooverror();
+  CreateTicketError = class CreateTicketError extends MoovError {
+    title;
+    author;
+    contact;
+    foreignID;
+    data$;
+    constructor(err, httpMeta) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message, httpMeta);
+      this.data$ = err;
+      if (err.title != null)
+        this.title = err.title;
+      if (err.author != null)
+        this.author = err.author;
+      if (err.contact != null)
+        this.contact = err.contact;
+      if (err.foreignID != null)
+        this.foreignID = err.foreignID;
+      this.name = "CreateTicketError";
+    }
+  };
+  CreateTicketError$inboundSchema = objectType({
+    title: stringType().optional(),
+    body: stringType().optional(),
+    author: stringType().optional(),
+    contact: CreateTicketContactError$inboundSchema.optional(),
+    foreignID: stringType().optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new CreateTicketError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  CreateTicketError$outboundSchema = instanceOfType(CreateTicketError).transform((v2) => v2.data$).pipe(objectType({
+    title: stringType().optional(),
+    body: stringType().optional(),
+    author: stringType().optional(),
+    contact: CreateTicketContactError$outboundSchema.optional(),
+    foreignID: stringType().optional()
+  }));
+});
+
 // src/models/errors/createwalletvalidationerror.ts
 var CreateWalletValidationError, CreateWalletValidationError$inboundSchema, CreateWalletValidationError$outboundSchema;
 var init_createwalletvalidationerror = __esm(() => {
@@ -69222,6 +70287,40 @@ var init_updatepaymentlinkerror = __esm(() => {
   }));
 });
 
+// src/models/errors/updateticketerror.ts
+var UpdateTicketError, UpdateTicketError$inboundSchema, UpdateTicketError$outboundSchema;
+var init_updateticketerror = __esm(() => {
+  init_esm();
+  init_mooverror();
+  UpdateTicketError = class UpdateTicketError extends MoovError {
+    status;
+    data$;
+    constructor(err, httpMeta) {
+      const message = "message" in err && typeof err.message === "string" ? err.message : `API error occurred: ${JSON.stringify(err)}`;
+      super(message, httpMeta);
+      this.data$ = err;
+      if (err.status != null)
+        this.status = err.status;
+      this.name = "UpdateTicketError";
+    }
+  };
+  UpdateTicketError$inboundSchema = objectType({
+    status: stringType().optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new UpdateTicketError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  UpdateTicketError$outboundSchema = instanceOfType(UpdateTicketError).transform((v2) => v2.data$).pipe(objectType({
+    status: stringType().optional()
+  }));
+});
+
 // src/models/errors/updateunderwritingerror.ts
 var UpdateUnderwritingError, UpdateUnderwritingErrorError$inboundSchema, UpdateUnderwritingErrorError$outboundSchema, UpdateUnderwritingError$inboundSchema, UpdateUnderwritingError$outboundSchema;
 var init_updateunderwritingerror = __esm(() => {
@@ -69321,6 +70420,114 @@ var init_updatewebhookvalidationerror = __esm(() => {
   }));
 });
 
+// src/models/errors/upsertunderwritingerror.ts
+var UpsertUnderwritingError, UpsertUnderwritingError$inboundSchema, UpsertUnderwritingError$outboundSchema;
+var init_upsertunderwritingerror = __esm(() => {
+  init_esm();
+  init_components();
+  init_mooverror();
+  UpsertUnderwritingError = class UpsertUnderwritingError extends MoovError {
+    geographicReach;
+    businessPresence;
+    pendingLitigation;
+    volumeShareByCustomerType;
+    collectFunds;
+    moneyTransfer;
+    sendFunds;
+    averageMonthlyTransactionVolume;
+    error;
+    averageTransactionSize;
+    maxTransactionSize;
+    volumeByCustomerType;
+    cardVolumeDistribution;
+    fulfillment;
+    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.geographicReach != null)
+        this.geographicReach = err.geographicReach;
+      if (err.businessPresence != null) {
+        this.businessPresence = err.businessPresence;
+      }
+      if (err.pendingLitigation != null) {
+        this.pendingLitigation = err.pendingLitigation;
+      }
+      if (err.volumeShareByCustomerType != null) {
+        this.volumeShareByCustomerType = err.volumeShareByCustomerType;
+      }
+      if (err.collectFunds != null)
+        this.collectFunds = err.collectFunds;
+      if (err.moneyTransfer != null)
+        this.moneyTransfer = err.moneyTransfer;
+      if (err.sendFunds != null)
+        this.sendFunds = err.sendFunds;
+      if (err.averageMonthlyTransactionVolume != null) {
+        this.averageMonthlyTransactionVolume = err.averageMonthlyTransactionVolume;
+      }
+      if (err.error != null)
+        this.error = err.error;
+      if (err.averageTransactionSize != null) {
+        this.averageTransactionSize = err.averageTransactionSize;
+      }
+      if (err.maxTransactionSize != null) {
+        this.maxTransactionSize = err.maxTransactionSize;
+      }
+      if (err.volumeByCustomerType != null) {
+        this.volumeByCustomerType = err.volumeByCustomerType;
+      }
+      if (err.cardVolumeDistribution != null) {
+        this.cardVolumeDistribution = err.cardVolumeDistribution;
+      }
+      if (err.fulfillment != null)
+        this.fulfillment = err.fulfillment;
+      this.name = "UpsertUnderwritingError";
+    }
+  };
+  UpsertUnderwritingError$inboundSchema = objectType({
+    geographicReach: stringType().optional(),
+    businessPresence: stringType().optional(),
+    pendingLitigation: stringType().optional(),
+    volumeShareByCustomerType: VolumeShareByCustomerTypeError$inboundSchema.optional(),
+    collectFunds: CollectFundsError$inboundSchema.optional(),
+    moneyTransfer: MoneyTransferError$inboundSchema.optional(),
+    sendFunds: SendFundsError$inboundSchema.optional(),
+    averageMonthlyTransactionVolume: stringType().optional(),
+    error: stringType().optional(),
+    averageTransactionSize: stringType().optional(),
+    maxTransactionSize: stringType().optional(),
+    volumeByCustomerType: VolumeByCustomerTypeError$inboundSchema.optional(),
+    cardVolumeDistribution: CardVolumeDistributionError$inboundSchema.optional(),
+    fulfillment: FulfillmentDetailsError$inboundSchema.optional(),
+    request$: instanceOfType(Request),
+    response$: instanceOfType(Response),
+    body$: stringType()
+  }).transform((v2) => {
+    return new UpsertUnderwritingError(v2, {
+      request: v2.request$,
+      response: v2.response$,
+      body: v2.body$
+    });
+  });
+  UpsertUnderwritingError$outboundSchema = instanceOfType(UpsertUnderwritingError).transform((v2) => v2.data$).pipe(objectType({
+    geographicReach: stringType().optional(),
+    businessPresence: stringType().optional(),
+    pendingLitigation: stringType().optional(),
+    volumeShareByCustomerType: VolumeShareByCustomerTypeError$outboundSchema.optional(),
+    collectFunds: CollectFundsError$outboundSchema.optional(),
+    moneyTransfer: MoneyTransferError$outboundSchema.optional(),
+    sendFunds: SendFundsError$outboundSchema.optional(),
+    averageMonthlyTransactionVolume: stringType().optional(),
+    error: stringType().optional(),
+    averageTransactionSize: stringType().optional(),
+    maxTransactionSize: stringType().optional(),
+    volumeByCustomerType: VolumeByCustomerTypeError$outboundSchema.optional(),
+    cardVolumeDistribution: CardVolumeDistributionError$outboundSchema.optional(),
+    fulfillment: FulfillmentDetailsError$outboundSchema.optional()
+  }));
+});
+
 // src/models/errors/index.ts
 var init_errors4 = __esm(() => {
   init_accountterminalapplicationerror();
@@ -69335,6 +70542,7 @@ var init_errors4 = __esm(() => {
   init_createaccounterror();
   init_createpaymentlinkerror();
   init_createsweepconfigerror();
+  init_createticketerror();
   init_createwalletvalidationerror();
   init_createwebhookvalidationerror();
   init_feeplanagreementerror();
@@ -69372,8 +70580,10 @@ var init_errors4 = __esm(() => {
   init_updatecarderror();
   init_updateissuedcarderror();
   init_updatepaymentlinkerror();
+  init_updateticketerror();
   init_updateunderwritingerror();
   init_updatewebhookvalidationerror();
+  init_upsertunderwritingerror();
 });
 
 // src/models/operations/acceptdispute.ts
@@ -70505,6 +71715,62 @@ var init_createterminalapplicationversion = __esm(() => {
   });
 });
 
+// src/models/operations/createticket.ts
+var CreateTicketGlobals$inboundSchema, CreateTicketGlobals$outboundSchema, CreateTicketRequest$inboundSchema, CreateTicketRequest$outboundSchema, CreateTicketResponse$inboundSchema, CreateTicketResponse$outboundSchema;
+var init_createticket2 = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  CreateTicketGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  CreateTicketGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  CreateTicketRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    CreateTicket: CreateTicket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      CreateTicket: "createTicket"
+    });
+  });
+  CreateTicketRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    createTicket: CreateTicket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      createTicket: "CreateTicket"
+    });
+  });
+  CreateTicketResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: Ticket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  CreateTicketResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Ticket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/createtransfer.ts
 var CreateTransferGlobals$inboundSchema, CreateTransferGlobals$outboundSchema, CreateTransferRequest$inboundSchema, CreateTransferRequest$outboundSchema, CreateTransferResponseResult$inboundSchema, CreateTransferResponseResult$outboundSchema, CreateTransferResponse$inboundSchema, CreateTransferResponse$outboundSchema;
 var init_createtransfer2 = __esm(() => {
@@ -73291,6 +74557,54 @@ var init_gettermsofservicetoken = __esm(() => {
   });
 });
 
+// src/models/operations/getticket.ts
+var GetTicketGlobals$inboundSchema, GetTicketGlobals$outboundSchema, GetTicketRequest$inboundSchema, GetTicketRequest$outboundSchema, GetTicketResponse$inboundSchema, GetTicketResponse$outboundSchema;
+var init_getticket = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  GetTicketGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  GetTicketGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  GetTicketRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType()
+  });
+  GetTicketRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType()
+  });
+  GetTicketResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: Ticket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  GetTicketResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Ticket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/gettransfer.ts
 var GetTransferGlobals$inboundSchema, GetTransferGlobals$outboundSchema, GetTransferRequest$inboundSchema, GetTransferRequest$outboundSchema, GetTransferResponse$inboundSchema, GetTransferResponse$outboundSchema;
 var init_gettransfer = __esm(() => {
@@ -74011,7 +75325,7 @@ var init_listaccounts = __esm(() => {
   ListAccountsRequest$inboundSchema = objectType({
     name: stringType().optional(),
     email: stringType().optional(),
-    type: AccountType$inboundSchema.optional(),
+    type: CreateAccountType$inboundSchema.optional(),
     foreignID: stringType().optional(),
     includeDisconnected: booleanType().optional(),
     capability: CapabilityID$inboundSchema.optional(),
@@ -74022,7 +75336,7 @@ var init_listaccounts = __esm(() => {
   ListAccountsRequest$outboundSchema = objectType({
     name: stringType().optional(),
     email: stringType().optional(),
-    type: AccountType$outboundSchema.optional(),
+    type: CreateAccountType$outboundSchema.optional(),
     foreignID: stringType().optional(),
     includeDisconnected: booleanType().optional(),
     capability: CapabilityID$outboundSchema.optional(),
@@ -74306,7 +75620,7 @@ var init_listconnectedaccountsforaccount = __esm(() => {
     accountID: stringType(),
     name: stringType().optional(),
     email: stringType().optional(),
-    type: AccountType$inboundSchema.optional(),
+    type: CreateAccountType$inboundSchema.optional(),
     foreignID: stringType().optional(),
     includeDisconnected: booleanType().optional(),
     capability: CapabilityID$inboundSchema.optional(),
@@ -74318,7 +75632,7 @@ var init_listconnectedaccountsforaccount = __esm(() => {
     accountID: stringType(),
     name: stringType().optional(),
     email: stringType().optional(),
-    type: AccountType$outboundSchema.optional(),
+    type: CreateAccountType$outboundSchema.optional(),
     foreignID: stringType().optional(),
     includeDisconnected: booleanType().optional(),
     capability: CapabilityID$outboundSchema.optional(),
@@ -75889,6 +77203,116 @@ var init_listterminalapplications = __esm(() => {
   });
 });
 
+// src/models/operations/listticketmessages.ts
+var ListTicketMessagesGlobals$inboundSchema, ListTicketMessagesGlobals$outboundSchema, ListTicketMessagesRequest$inboundSchema, ListTicketMessagesRequest$outboundSchema, ListTicketMessagesResponse$inboundSchema, ListTicketMessagesResponse$outboundSchema;
+var init_listticketmessages = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ListTicketMessagesGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  ListTicketMessagesGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  ListTicketMessagesRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType()
+  });
+  ListTicketMessagesRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType()
+  });
+  ListTicketMessagesResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: arrayType(TicketMessage$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ListTicketMessagesResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: arrayType(TicketMessage$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
+// src/models/operations/listtickets.ts
+var ListTicketsGlobals$inboundSchema, ListTicketsGlobals$outboundSchema, ListTicketsRequest$inboundSchema, ListTicketsRequest$outboundSchema, ListTicketsResponseBody$inboundSchema, ListTicketsResponseBody$outboundSchema, ListTicketsResponse$inboundSchema, ListTicketsResponse$outboundSchema;
+var init_listtickets = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  ListTicketsGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  ListTicketsGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  ListTicketsRequest$inboundSchema = objectType({
+    cursor: stringType().optional(),
+    count: numberType().int().optional(),
+    status: TicketStatus$inboundSchema.optional(),
+    foreignID: stringType().optional(),
+    accountID: stringType()
+  });
+  ListTicketsRequest$outboundSchema = objectType({
+    cursor: stringType().optional(),
+    count: numberType().int().optional(),
+    status: TicketStatus$outboundSchema.optional(),
+    foreignID: stringType().optional(),
+    accountID: stringType()
+  });
+  ListTicketsResponseBody$inboundSchema = objectType({
+    items: arrayType(Ticket$inboundSchema),
+    nextPage: ItemListNextPage$inboundSchema.optional()
+  });
+  ListTicketsResponseBody$outboundSchema = objectType({
+    items: arrayType(Ticket$outboundSchema),
+    nextPage: ItemListNextPage$outboundSchema.optional()
+  });
+  ListTicketsResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: lazyType(() => ListTicketsResponseBody$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  ListTicketsResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: lazyType(() => ListTicketsResponseBody$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/listtransfers.ts
 var ListTransfersGlobals$inboundSchema, ListTransfersGlobals$outboundSchema, ListTransfersRequest$inboundSchema, ListTransfersRequest$outboundSchema, ListTransfersResponse$inboundSchema, ListTransfersResponse$outboundSchema;
 var init_listtransfers = __esm(() => {
@@ -76514,6 +77938,62 @@ var init_revokeonboardinginvite = __esm(() => {
   });
 });
 
+// src/models/operations/saveunderwriting.ts
+var SaveUnderwritingGlobals$inboundSchema, SaveUnderwritingGlobals$outboundSchema, SaveUnderwritingRequest$inboundSchema, SaveUnderwritingRequest$outboundSchema, SaveUnderwritingResponse$inboundSchema, SaveUnderwritingResponse$outboundSchema;
+var init_saveunderwriting = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  SaveUnderwritingGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  SaveUnderwritingGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  SaveUnderwritingRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    UpsertUnderwriting: UpsertUnderwriting$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      UpsertUnderwriting: "upsertUnderwriting"
+    });
+  });
+  SaveUnderwritingRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    upsertUnderwriting: UpsertUnderwriting$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      upsertUnderwriting: "UpsertUnderwriting"
+    });
+  });
+  SaveUnderwritingResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: Underwriting$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  SaveUnderwritingResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Underwriting$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/searchinstitutions.ts
 var SearchInstitutionsGlobals$inboundSchema, SearchInstitutionsGlobals$outboundSchema, SearchInstitutionsRequest$inboundSchema, SearchInstitutionsRequest$outboundSchema, SearchInstitutionsResponse$inboundSchema, SearchInstitutionsResponse$outboundSchema;
 var init_searchinstitutions = __esm(() => {
@@ -77333,6 +78813,64 @@ var init_updatesweepconfig = __esm(() => {
   });
 });
 
+// src/models/operations/updateticket.ts
+var UpdateTicketGlobals$inboundSchema, UpdateTicketGlobals$outboundSchema, UpdateTicketRequest$inboundSchema, UpdateTicketRequest$outboundSchema, UpdateTicketResponse$inboundSchema, UpdateTicketResponse$outboundSchema;
+var init_updateticket2 = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_components();
+  UpdateTicketGlobals$inboundSchema = objectType({
+    "X-Moov-Version": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-Moov-Version": "xMoovVersion"
+    });
+  });
+  UpdateTicketGlobals$outboundSchema = objectType({
+    xMoovVersion: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      xMoovVersion: "X-Moov-Version"
+    });
+  });
+  UpdateTicketRequest$inboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType(),
+    UpdateTicket: UpdateTicket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      UpdateTicket: "updateTicket"
+    });
+  });
+  UpdateTicketRequest$outboundSchema = objectType({
+    accountID: stringType(),
+    ticketID: stringType(),
+    updateTicket: UpdateTicket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      updateTicket: "UpdateTicket"
+    });
+  });
+  UpdateTicketResponse$inboundSchema = objectType({
+    Headers: recordType(arrayType(stringType())).default({}),
+    Result: Ticket$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Headers: "headers",
+      Result: "result"
+    });
+  });
+  UpdateTicketResponse$outboundSchema = objectType({
+    headers: recordType(arrayType(stringType())),
+    result: Ticket$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      headers: "Headers",
+      result: "Result"
+    });
+  });
+});
+
 // src/models/operations/updatetransfer.ts
 var UpdateTransferGlobals$inboundSchema, UpdateTransferGlobals$outboundSchema, UpdateTransferRequest$inboundSchema, UpdateTransferRequest$outboundSchema, UpdateTransferResponse$inboundSchema, UpdateTransferResponse$outboundSchema;
 var init_updatetransfer = __esm(() => {
@@ -77791,7 +79329,7 @@ var init_upsertbrand = __esm(() => {
 
 // src/models/operations/upsertunderwriting.ts
 var UpsertUnderwritingGlobals$inboundSchema, UpsertUnderwritingGlobals$outboundSchema, UpsertUnderwritingRequest$inboundSchema, UpsertUnderwritingRequest$outboundSchema, UpsertUnderwritingResponse$inboundSchema, UpsertUnderwritingResponse$outboundSchema;
-var init_upsertunderwriting = __esm(() => {
+var init_upsertunderwriting2 = __esm(() => {
   init_esm();
   init_primitives();
   init_components();
@@ -77869,6 +79407,7 @@ var init_operations = __esm(() => {
   init_createsweepconfig2();
   init_createterminalapplication2();
   init_createterminalapplicationversion();
+  init_createticket2();
   init_createtransfer2();
   init_createtransferoptions2();
   init_createwallet2();
@@ -77926,6 +79465,7 @@ var init_operations = __esm(() => {
   init_getterminalapplication();
   init_getterminalconfiguration();
   init_gettermsofservicetoken();
+  init_getticket();
   init_gettransfer();
   init_getunderwriting();
   init_getwallet();
@@ -77976,6 +79516,8 @@ var init_operations = __esm(() => {
   init_listsweepconfigs();
   init_listsweeps();
   init_listterminalapplications();
+  init_listticketmessages();
+  init_listtickets();
   init_listtransfers();
   init_listwallets();
   init_listwallettransactions();
@@ -77988,6 +79530,7 @@ var init_operations = __esm(() => {
   init_retrievefees();
   init_revokeaccesstoken();
   init_revokeonboardinginvite();
+  init_saveunderwriting();
   init_searchinstitutions();
   init_submitdisputeevidence();
   init_testendtoendtoken();
@@ -78003,6 +79546,7 @@ var init_operations = __esm(() => {
   init_updaterepresentative2();
   init_updateschedule();
   init_updatesweepconfig();
+  init_updateticket2();
   init_updatetransfer();
   init_updatewallet();
   init_updatewebhook2();
@@ -78011,7 +79555,7 @@ var init_operations = __esm(() => {
   init_uploadfile();
   init_uploadimage();
   init_upsertbrand();
-  init_upsertunderwriting();
+  init_upsertunderwriting2();
 });
 
 // src/types/async.ts
@@ -93400,24 +94944,24 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
   };
 });
 
-// src/funcs/sweepsCreateConfig.ts
-function sweepsCreateConfig(client, request, options) {
+// src/funcs/supportCreateTicket.ts
+function supportCreateTicket(client, request, options) {
   return new APIPromise($do128(client, request, options));
 }
 async function $do128(client, request, options) {
-  const parsed = safeParse4(request, (value) => CreateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => CreateTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.CreateSweepConfig, { explode: true });
+  const body = encodeJSON("body", payload.CreateTicket, { explode: true });
   const pathParams = {
     accountID: encodeSimple("accountID", payload.accountID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/sweep-configs")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets")(pathParams);
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/json",
@@ -93428,7 +94972,7 @@ async function $do128(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "createSweepConfig",
+    operationID: "createTicket",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -93474,16 +95018,16 @@ async function $do128(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, CreateSweepConfigResponse$inboundSchema, {
+  const [result] = await match(json(200, CreateTicketResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
-  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, CreateSweepConfigError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, CreateTicketError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sweepsCreateConfig = __esm(() => {
+var init_supportCreateTicket = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -93495,24 +95039,27 @@ var init_sweepsCreateConfig = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/sweepsCreateConfig.ts
-var args128, tool$sweepsCreateConfig;
-var init_sweepsCreateConfig2 = __esm(() => {
-  init_sweepsCreateConfig();
+// src/mcp-server/tools/supportCreateTicket.ts
+var args128, tool$supportCreateTicket;
+var init_supportCreateTicket2 = __esm(() => {
+  init_supportCreateTicket();
   init_operations();
   init_tools();
   args128 = {
-    request: CreateSweepConfigRequest$inboundSchema
+    request: CreateTicketRequest$inboundSchema
   };
-  tool$sweepsCreateConfig = {
-    name: "sweeps-create-config",
-    description: `Create a sweep config for a wallet.
+  tool$supportCreateTicket = {
+    name: "support-create-ticket",
+    description: `Create a support ticket for a Moov account.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
+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 sweepsCreateConfig(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await supportCreateTicket(client, args129.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -93525,12 +95072,12 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
   };
 });
 
-// src/funcs/sweepsGet.ts
-function sweepsGet(client, request, options) {
+// src/funcs/supportGetTicket.ts
+function supportGetTicket(client, request, options) {
   return new APIPromise($do129(client, request, options));
 }
 async function $do129(client, request, options) {
-  const parsed = safeParse4(request, (value) => GetSweepRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => GetTicketRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -93541,16 +95088,12 @@ async function $do129(client, request, options) {
       explode: false,
       charEncoding: "percent"
     }),
-    sweepID: encodeSimple("sweepID", payload.sweepID, {
-      explode: false,
-      charEncoding: "percent"
-    }),
-    walletID: encodeSimple("walletID", payload.walletID, {
+    ticketID: encodeSimple("ticketID", payload.ticketID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/wallets/{walletID}/sweeps/{sweepID}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets/{ticketID}")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "X-Moov-Version": encodeSimple("X-Moov-Version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
@@ -93560,7 +95103,7 @@ async function $do129(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getSweep",
+    operationID: "getTicket",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -93594,7 +95137,7 @@ async function $do129(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, GetSweepResponse$inboundSchema, {
+  const [result] = await match(json(200, GetTicketResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
   }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
@@ -93603,7 +95146,7 @@ async function $do129(client, request, options) {
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sweepsGet = __esm(() => {
+var init_supportGetTicket = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -93614,24 +95157,27 @@ var init_sweepsGet = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/sweepsGet.ts
-var args129, tool$sweepsGet;
-var init_sweepsGet2 = __esm(() => {
-  init_sweepsGet();
+// src/mcp-server/tools/supportGetTicket.ts
+var args129, tool$supportGetTicket;
+var init_supportGetTicket2 = __esm(() => {
+  init_supportGetTicket();
   init_operations();
   init_tools();
   args129 = {
-    request: GetSweepRequest$inboundSchema
+    request: GetTicketRequest$inboundSchema
   };
-  tool$sweepsGet = {
-    name: "sweeps-get",
-    description: `Get details on a specific sweep.
+  tool$supportGetTicket = {
+    name: "support-get-ticket",
+    description: `Retrieve a support ticket by ID.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
+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 sweepsGet(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await supportGetTicket(client, args130.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -93644,12 +95190,12 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
   };
 });
 
-// src/funcs/sweepsGetConfig.ts
-function sweepsGetConfig(client, request, options) {
+// src/funcs/supportListTicketMessages.ts
+function supportListTicketMessages(client, request, options) {
   return new APIPromise($do130(client, request, options));
 }
 async function $do130(client, request, options) {
-  const parsed = safeParse4(request, (value) => GetSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => ListTicketMessagesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -93660,12 +95206,12 @@ async function $do130(client, request, options) {
       explode: false,
       charEncoding: "percent"
     }),
-    sweepConfigID: encodeSimple("sweepConfigID", payload.sweepConfigID, {
+    ticketID: encodeSimple("ticketID", payload.ticketID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/sweep-configs/{sweepConfigID}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets/{ticketID}/messages")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "X-Moov-Version": encodeSimple("X-Moov-Version", client._options.xMoovVersion, { explode: false, charEncoding: "none" })
@@ -93675,7 +95221,7 @@ async function $do130(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "getSweepConfig",
+    operationID: "listTicketMessages",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -93698,7 +95244,7 @@ async function $do130(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["401", "403", "404", "429", "4XX", "500", "504", "5XX"],
+    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -93709,16 +95255,16 @@ async function $do130(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, GetSweepConfigResponse$inboundSchema, {
+  const [result] = await match(json(200, ListTicketMessagesResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
-  }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sweepsGetConfig = __esm(() => {
+var init_supportListTicketMessages = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -93729,24 +95275,27 @@ var init_sweepsGetConfig = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/sweepsGetConfig.ts
-var args130, tool$sweepsGetConfig;
-var init_sweepsGetConfig2 = __esm(() => {
-  init_sweepsGetConfig();
+// src/mcp-server/tools/supportListTicketMessages.ts
+var args130, tool$supportListTicketMessages;
+var init_supportListTicketMessages2 = __esm(() => {
+  init_supportListTicketMessages();
   init_operations();
   init_tools();
   args130 = {
-    request: GetSweepConfigRequest$inboundSchema
+    request: ListTicketMessagesRequest$inboundSchema
   };
-  tool$sweepsGetConfig = {
-    name: "sweeps-get-config",
-    description: `Get a sweep config associated with a wallet.
+  tool$supportListTicketMessages = {
+    name: "support-list-ticket-messages",
+    description: `List all the messages for a support ticket.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
+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 sweepsGetConfig(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await supportListTicketMessages(client, args131.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -93759,12 +95308,12 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
   };
 });
 
-// src/funcs/sweepsList.ts
-function sweepsList(client, request, options) {
+// src/funcs/supportListTickets.ts
+function supportListTickets(client, request, options) {
   return new APIPromise($do131(client, request, options));
 }
 async function $do131(client, request, options) {
-  const parsed = safeParse4(request, (value) => ListSweepsRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => ListTicketsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
@@ -93774,17 +95323,13 @@ async function $do131(client, request, options) {
     accountID: encodeSimple("accountID", payload.accountID, {
       explode: false,
       charEncoding: "percent"
-    }),
-    walletID: encodeSimple("walletID", payload.walletID, {
-      explode: false,
-      charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/wallets/{walletID}/sweeps")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets")(pathParams);
   const query = encodeFormQuery({
     count: payload.count,
-    skip: payload.skip,
-    statementDescriptor: payload.statementDescriptor,
+    cursor: payload.cursor,
+    foreignID: payload.foreignID,
     status: payload.status
   }, { explode: false });
   const headers = new Headers(compactMap({
@@ -93796,7 +95341,7 @@ async function $do131(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "listSweeps",
+    operationID: "listTickets",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -93831,7 +95376,7 @@ async function $do131(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, ListSweepsResponse$inboundSchema, {
+  const [result] = await match(json(200, ListTicketsResponse$inboundSchema, {
     hdrs: true,
     key: "Result"
   }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
@@ -93840,7 +95385,7 @@ async function $do131(client, request, options) {
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_sweepsList = __esm(() => {
+var init_supportListTickets = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -93851,24 +95396,27 @@ var init_sweepsList = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/sweepsList.ts
-var args131, tool$sweepsList;
-var init_sweepsList2 = __esm(() => {
-  init_sweepsList();
+// src/mcp-server/tools/supportListTickets.ts
+var args131, tool$supportListTickets;
+var init_supportListTickets2 = __esm(() => {
+  init_supportListTickets();
   init_operations();
   init_tools();
   args131 = {
-    request: ListSweepsRequest$inboundSchema
+    request: ListTicketsRequest$inboundSchema
   };
-  tool$sweepsList = {
-    name: "sweeps-list",
-    description: `List sweeps associated with a wallet.
+  tool$supportListTickets = {
+    name: "support-list-tickets",
+    description: `List all the support tickets created under a Moov account.
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
-you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
+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 sweepsList(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await supportListTickets(client, args132.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -93881,139 +95429,28 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
   };
 });
 
-// src/funcs/sweepsListConfigs.ts
-function sweepsListConfigs(client, request, options) {
+// src/funcs/supportUpdateTicket.ts
+function supportUpdateTicket(client, request, options) {
   return new APIPromise($do132(client, request, options));
 }
 async function $do132(client, request, options) {
-  const parsed = safeParse4(request, (value) => ListSweepConfigsRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse4(request, (value) => UpdateTicketRequest$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}/sweep-configs")(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: "listSweepConfigs",
-    oAuth2Scopes: null,
-    resolvedSecurity: requestSecurity,
-    securitySource: client._options.security,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
-  };
-  const requestRes = client._createRequest(context, {
-    security: requestSecurity,
-    method: "GET",
-    baseURL: options?.serverURL,
-    path,
-    headers,
-    body,
-    userAgent: client._options.userAgent,
-    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
-  }, options);
-  if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
-  }
-  const req = requestRes.value;
-  const doResult = await client._do(req, {
-    context,
-    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
-    retryConfig: context.retryConfig,
-    retryCodes: context.retryCodes
-  });
-  if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
-  }
-  const response = doResult.value;
-  const responseFields = {
-    HttpMeta: { Response: response, Request: req }
-  };
-  const [result] = await match(json(200, ListSweepConfigsResponse$inboundSchema, {
-    hdrs: true,
-    key: "Result"
-  }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
-  if (!result.ok) {
-    return [result, { status: "complete", request: req, response }];
-  }
-  return [result, { status: "complete", request: req, response }];
-}
-var init_sweepsListConfigs = __esm(() => {
-  init_encodings();
-  init_matchers();
-  init_primitives();
-  init_schemas4();
-  init_security();
-  init_url();
-  init_operations();
-  init_async();
-});
-
-// src/mcp-server/tools/sweepsListConfigs.ts
-var args132, tool$sweepsListConfigs;
-var init_sweepsListConfigs2 = __esm(() => {
-  init_sweepsListConfigs();
-  init_operations();
-  init_tools();
-  args132 = {
-    request: ListSweepConfigsRequest$inboundSchema
-  };
-  tool$sweepsListConfigs = {
-    name: "sweeps-list-configs",
-    description: `List sweep configs associated with an 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}/wallets.read\` scope.`,
-    args: args132,
-    tool: async (client, args133, ctx) => {
-      const [result, apiCall] = await sweepsListConfigs(client, args133.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
-      if (!result.ok) {
-        return {
-          content: [{ type: "text", text: result.error.message }],
-          isError: true
-        };
-      }
-      const value = result.value.result;
-      return formatResult(value, apiCall);
-    }
-  };
-});
-
-// src/funcs/sweepsUpdateConfig.ts
-function sweepsUpdateConfig(client, request, options) {
-  return new APIPromise($do133(client, request, options));
-}
-async function $do133(client, request, options) {
-  const parsed = safeParse4(request, (value) => UpdateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
-  if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
-  }
-  const payload = parsed.value;
-  const body = encodeJSON("body", payload.PatchSweepConfig, { explode: true });
+  const body = encodeJSON("body", payload.UpdateTicket, { explode: true });
   const pathParams = {
     accountID: encodeSimple("accountID", payload.accountID, {
       explode: false,
       charEncoding: "percent"
     }),
-    sweepConfigID: encodeSimple("sweepConfigID", payload.sweepConfigID, {
+    ticketID: encodeSimple("ticketID", payload.ticketID, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/accounts/{accountID}/sweep-configs/{sweepConfigID}")(pathParams);
+  const path = pathToFunc("/accounts/{accountID}/tickets/{ticketID}")(pathParams);
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
     Accept: "application/json",
@@ -94024,7 +95461,731 @@ async function $do133(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "updateSweepConfig",
+    operationID: "updateTicket",
+    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, UpdateTicketResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, UpdateTicketError$inboundSchema, { hdrs: true }), fail([401, 403, 404, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_supportUpdateTicket = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/supportUpdateTicket.ts
+var args132, tool$supportUpdateTicket;
+var init_supportUpdateTicket2 = __esm(() => {
+  init_supportUpdateTicket();
+  init_operations();
+  init_tools();
+  args132 = {
+    request: UpdateTicketRequest$inboundSchema
+  };
+  tool$supportUpdateTicket = {
+    name: "support-update-ticket",
+    description: `Updates a support ticket.
+
+To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/)
+you'll need to specify the \`/accounts/{accountID}/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();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/sweepsCreateConfig.ts
+function sweepsCreateConfig(client, request, options) {
+  return new APIPromise($do133(client, request, options));
+}
+async function $do133(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.CreateSweepConfig, { explode: true });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/sweep-configs")(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: "createSweepConfig",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, CreateSweepConfigResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, CreateSweepConfigError$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_sweepsCreateConfig = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/sweepsCreateConfig.ts
+var args133, tool$sweepsCreateConfig;
+var init_sweepsCreateConfig2 = __esm(() => {
+  init_sweepsCreateConfig();
+  init_operations();
+  init_tools();
+  args133 = {
+    request: CreateSweepConfigRequest$inboundSchema
+  };
+  tool$sweepsCreateConfig = {
+    name: "sweeps-create-config",
+    description: `Create a sweep config for a wallet.
+
+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();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/sweepsGet.ts
+function sweepsGet(client, request, options) {
+  return new APIPromise($do134(client, request, options));
+}
+async function $do134(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetSweepRequest$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"
+    }),
+    sweepID: encodeSimple("sweepID", payload.sweepID, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    walletID: encodeSimple("walletID", payload.walletID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/wallets/{walletID}/sweeps/{sweepID}")(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: "getSweep",
+    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, GetSweepResponse$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_sweepsGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/sweepsGet.ts
+var args134, tool$sweepsGet;
+var init_sweepsGet2 = __esm(() => {
+  init_sweepsGet();
+  init_operations();
+  init_tools();
+  args134 = {
+    request: GetSweepRequest$inboundSchema
+  };
+  tool$sweepsGet = {
+    name: "sweeps-get",
+    description: `Get details on a specific sweep.
+
+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();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/sweepsGetConfig.ts
+function sweepsGetConfig(client, request, options) {
+  return new APIPromise($do135(client, request, options));
+}
+async function $do135(client, request, options) {
+  const parsed = safeParse4(request, (value) => GetSweepConfigRequest$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"
+    }),
+    sweepConfigID: encodeSimple("sweepConfigID", payload.sweepConfigID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/sweep-configs/{sweepConfigID}")(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: "getSweepConfig",
+    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, GetSweepConfigResponse$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_sweepsGetConfig = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/sweepsGetConfig.ts
+var args135, tool$sweepsGetConfig;
+var init_sweepsGetConfig2 = __esm(() => {
+  init_sweepsGetConfig();
+  init_operations();
+  init_tools();
+  args135 = {
+    request: GetSweepConfigRequest$inboundSchema
+  };
+  tool$sweepsGetConfig = {
+    name: "sweeps-get-config",
+    description: `Get a sweep config associated with a wallet.
+
+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();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/sweepsList.ts
+function sweepsList(client, request, options) {
+  return new APIPromise($do136(client, request, options));
+}
+async function $do136(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListSweepsRequest$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"
+    }),
+    walletID: encodeSimple("walletID", payload.walletID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/wallets/{walletID}/sweeps")(pathParams);
+  const query = encodeFormQuery({
+    count: payload.count,
+    skip: payload.skip,
+    statementDescriptor: payload.statementDescriptor,
+    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: "listSweeps",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, ListSweepsResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_sweepsList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/sweepsList.ts
+var args136, tool$sweepsList;
+var init_sweepsList2 = __esm(() => {
+  init_sweepsList();
+  init_operations();
+  init_tools();
+  args136 = {
+    request: ListSweepsRequest$inboundSchema
+  };
+  tool$sweepsList = {
+    name: "sweeps-list",
+    description: `List sweeps associated with a wallet.
+
+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();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value.result;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/sweepsListConfigs.ts
+function sweepsListConfigs(client, request, options) {
+  return new APIPromise($do137(client, request, options));
+}
+async function $do137(client, request, options) {
+  const parsed = safeParse4(request, (value) => ListSweepConfigsRequest$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}/sweep-configs")(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: "listSweepConfigs",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["401", "403", "429", "4XX", "500", "504", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, ListSweepConfigsResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), fail([401, 403, 429]), fail([500, 504]), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_sweepsListConfigs = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/sweepsListConfigs.ts
+var args137, tool$sweepsListConfigs;
+var init_sweepsListConfigs2 = __esm(() => {
+  init_sweepsListConfigs();
+  init_operations();
+  init_tools();
+  args137 = {
+    request: ListSweepConfigsRequest$inboundSchema
+  };
+  tool$sweepsListConfigs = {
+    name: "sweeps-list-configs",
+    description: `List sweep configs associated with an 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}/wallets.read\` scope.`,
+    args: args137,
+    tool: async (client, args138, ctx) => {
+      const [result, apiCall] = await sweepsListConfigs(client, args138.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/sweepsUpdateConfig.ts
+function sweepsUpdateConfig(client, request, options) {
+  return new APIPromise($do138(client, request, options));
+}
+async function $do138(client, request, options) {
+  const parsed = safeParse4(request, (value) => UpdateSweepConfigRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.PatchSweepConfig, { explode: true });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    }),
+    sweepConfigID: encodeSimple("sweepConfigID", payload.sweepConfigID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/sweep-configs/{sweepConfigID}")(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: "updateSweepConfig",
     oAuth2Scopes: null,
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -94092,12 +96253,12 @@ var init_sweepsUpdateConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/sweepsUpdateConfig.ts
-var args133, tool$sweepsUpdateConfig;
+var args138, tool$sweepsUpdateConfig;
 var init_sweepsUpdateConfig2 = __esm(() => {
   init_sweepsUpdateConfig();
   init_operations();
   init_tools();
-  args133 = {
+  args138 = {
     request: UpdateSweepConfigRequest$inboundSchema
   };
   tool$sweepsUpdateConfig = {
@@ -94106,9 +96267,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: args133,
-    tool: async (client, args134, ctx) => {
-      const [result, apiCall] = await sweepsUpdateConfig(client, args134.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args138,
+    tool: async (client, args139, ctx) => {
+      const [result, apiCall] = await sweepsUpdateConfig(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -94123,9 +96284,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreate.ts
 function terminalApplicationsCreate(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 = safeParse4(request, (value) => CreateTerminalApplication$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -94214,12 +96375,12 @@ var init_terminalApplicationsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreate.ts
-var args134, tool$terminalApplicationsCreate;
+var args139, tool$terminalApplicationsCreate;
 var init_terminalApplicationsCreate2 = __esm(() => {
   init_terminalApplicationsCreate();
   init_components();
   init_tools();
-  args134 = {
+  args139 = {
     request: CreateTerminalApplication$inboundSchema
   };
   tool$terminalApplicationsCreate = {
@@ -94228,9 +96389,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: args134,
-    tool: async (client, args135, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreate(client, args135.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args139,
+    tool: async (client, args140, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreate(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -94245,9 +96406,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsCreateVersion.ts
 function terminalApplicationsCreateVersion(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 = safeParse4(request, (value) => CreateTerminalApplicationVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -94337,12 +96498,12 @@ var init_terminalApplicationsCreateVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsCreateVersion.ts
-var args135, tool$terminalApplicationsCreateVersion;
+var args140, tool$terminalApplicationsCreateVersion;
 var init_terminalApplicationsCreateVersion2 = __esm(() => {
   init_terminalApplicationsCreateVersion();
   init_operations();
   init_tools();
-  args135 = {
+  args140 = {
     request: CreateTerminalApplicationVersionRequest$inboundSchema
   };
   tool$terminalApplicationsCreateVersion = {
@@ -94351,9 +96512,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: args135,
-    tool: async (client, args136, ctx) => {
-      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args136.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args140,
+    tool: async (client, args141, ctx) => {
+      const [result, apiCall] = await terminalApplicationsCreateVersion(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -94368,9 +96529,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsDelete.ts
 function terminalApplicationsDelete(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 = safeParse4(request, (value) => DeleteTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -94454,12 +96615,12 @@ var init_terminalApplicationsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsDelete.ts
-var args136, tool$terminalApplicationsDelete;
+var args141, tool$terminalApplicationsDelete;
 var init_terminalApplicationsDelete2 = __esm(() => {
   init_terminalApplicationsDelete();
   init_operations();
   init_tools();
-  args136 = {
+  args141 = {
     request: DeleteTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsDelete = {
@@ -94468,9 +96629,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: args136,
-    tool: async (client, args137, ctx) => {
-      const [result, apiCall] = await terminalApplicationsDelete(client, args137.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args141,
+    tool: async (client, args142, ctx) => {
+      const [result, apiCall] = await terminalApplicationsDelete(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -94484,9 +96645,9 @@ you'll need to specify the \`/terminal-applications.write\` scope.`,
 
 // src/funcs/terminalApplicationsGet.ts
 function terminalApplicationsGet(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 = safeParse4(request, (value) => GetTerminalApplicationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -94561,12 +96722,12 @@ var init_terminalApplicationsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsGet.ts
-var args137, tool$terminalApplicationsGet;
+var args142, tool$terminalApplicationsGet;
 var init_terminalApplicationsGet2 = __esm(() => {
   init_terminalApplicationsGet();
   init_operations();
   init_tools();
-  args137 = {
+  args142 = {
     request: GetTerminalApplicationRequest$inboundSchema
   };
   tool$terminalApplicationsGet = {
@@ -94575,9 +96736,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: args137,
-    tool: async (client, args138, ctx) => {
-      const [result, apiCall] = await terminalApplicationsGet(client, args138.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args142,
+    tool: async (client, args143, ctx) => {
+      const [result, apiCall] = await terminalApplicationsGet(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -94592,9 +96753,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/terminalApplicationsList.ts
 function terminalApplicationsList(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 path = pathToFunc("/terminal-applications")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -94658,12 +96819,12 @@ var init_terminalApplicationsList = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalApplicationsList.ts
-var args138, tool$terminalApplicationsList;
+var args143, tool$terminalApplicationsList;
 var init_terminalApplicationsList2 = __esm(() => {
   init_terminalApplicationsList();
   init_operations();
   init_tools();
-  args138 = {
+  args143 = {
     request: ListTerminalApplicationsRequest$inboundSchema
   };
   tool$terminalApplicationsList = {
@@ -94672,9 +96833,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: args138,
-    tool: async (client, args139, ctx) => {
-      const [result, apiCall] = await terminalApplicationsList(client, args139.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args143,
+    tool: async (client, args144, ctx) => {
+      const [result, apiCall] = await terminalApplicationsList(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -94689,9 +96850,9 @@ you'll need to specify the \`/terminal-applications.read\` scope.`,
 
 // src/funcs/transfersCreate.ts
 function transfersCreate(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 = safeParse4(request, (value) => CreateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -94784,12 +96945,12 @@ var init_transfersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreate.ts
-var args139, tool$transfersCreate;
+var args144, tool$transfersCreate;
 var init_transfersCreate2 = __esm(() => {
   init_transfersCreate();
   init_operations();
   init_tools();
-  args139 = {
+  args144 = {
     request: CreateTransferRequest$inboundSchema
   };
   tool$transfersCreate = {
@@ -94800,9 +96961,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: args139,
-    tool: async (client, args140, ctx) => {
-      const [result, apiCall] = await transfersCreate(client, args140.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args144,
+    tool: async (client, args145, ctx) => {
+      const [result, apiCall] = await transfersCreate(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -94817,9 +96978,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersCreateCancellation.ts
 function transfersCreateCancellation(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 = safeParse4(request, (value) => CreateCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -94902,12 +97063,12 @@ var init_transfersCreateCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateCancellation.ts
-var args140, tool$transfersCreateCancellation;
+var args145, tool$transfersCreateCancellation;
 var init_transfersCreateCancellation2 = __esm(() => {
   init_transfersCreateCancellation();
   init_operations();
   init_tools();
-  args140 = {
+  args145 = {
     request: CreateCancellationRequest$inboundSchema
   };
   tool$transfersCreateCancellation = {
@@ -94916,9 +97077,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: args140,
-    tool: async (client, args141, ctx) => {
-      const [result, apiCall] = await transfersCreateCancellation(client, args141.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args145,
+    tool: async (client, args146, ctx) => {
+      const [result, apiCall] = await transfersCreateCancellation(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -94933,9 +97094,9 @@ var init_transfersCreateCancellation2 = __esm(() => {
 
 // src/funcs/transfersCreateReversal.ts
 function transfersCreateReversal(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 = safeParse4(request, (value) => CreateReversalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -95034,12 +97195,12 @@ var init_transfersCreateReversal = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersCreateReversal.ts
-var args141, tool$transfersCreateReversal;
+var args146, tool$transfersCreateReversal;
 var init_transfersCreateReversal2 = __esm(() => {
   init_transfersCreateReversal();
   init_operations();
   init_tools();
-  args141 = {
+  args146 = {
     request: CreateReversalRequest$inboundSchema
   };
   tool$transfersCreateReversal = {
@@ -95050,9 +97211,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: args141,
-    tool: async (client, args142, ctx) => {
-      const [result, apiCall] = await transfersCreateReversal(client, args142.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args146,
+    tool: async (client, args147, ctx) => {
+      const [result, apiCall] = await transfersCreateReversal(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -95067,9 +97228,9 @@ to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGenerateOptions.ts
 function transfersGenerateOptions(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 = safeParse4(request, (value) => CreateTransferOptionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -95153,12 +97314,12 @@ var init_transfersGenerateOptions = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGenerateOptions.ts
-var args142, tool$transfersGenerateOptions;
+var args147, tool$transfersGenerateOptions;
 var init_transfersGenerateOptions2 = __esm(() => {
   init_transfersGenerateOptions();
   init_operations();
   init_tools();
-  args142 = {
+  args147 = {
     request: CreateTransferOptionsRequest$inboundSchema
   };
   tool$transfersGenerateOptions = {
@@ -95172,9 +97333,9 @@ Read our [transfers overview guide](https://docs.moov.io/guides/money-movement/o
 
 To access this endpoint using an [access token](https://docs.moov.io/api/authentication/access-tokens/) 
 you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
-    args: args142,
-    tool: async (client, args143, ctx) => {
-      const [result, apiCall] = await transfersGenerateOptions(client, args143.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args147,
+    tool: async (client, args148, ctx) => {
+      const [result, apiCall] = await transfersGenerateOptions(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -95189,9 +97350,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersGet.ts
 function transfersGet(client, request, options) {
-  return new APIPromise($do143(client, request, options));
+  return new APIPromise($do148(client, request, options));
 }
-async function $do143(client, request, options) {
+async function $do148(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -95273,12 +97434,12 @@ var init_transfersGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGet.ts
-var args143, tool$transfersGet;
+var args148, tool$transfersGet;
 var init_transfersGet2 = __esm(() => {
   init_transfersGet();
   init_operations();
   init_tools();
-  args143 = {
+  args148 = {
     request: GetTransferRequest$inboundSchema
   };
   tool$transfersGet = {
@@ -95290,9 +97451,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: args143,
-    tool: async (client, args144, ctx) => {
-      const [result, apiCall] = await transfersGet(client, args144.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args148,
+    tool: async (client, args149, ctx) => {
+      const [result, apiCall] = await transfersGet(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -95307,9 +97468,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersGetCancellation.ts
 function transfersGetCancellation(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 = safeParse4(request, (value) => GetCancellationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -95395,12 +97556,12 @@ var init_transfersGetCancellation = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetCancellation.ts
-var args144, tool$transfersGetCancellation;
+var args149, tool$transfersGetCancellation;
 var init_transfersGetCancellation2 = __esm(() => {
   init_transfersGetCancellation();
   init_operations();
   init_tools();
-  args144 = {
+  args149 = {
     request: GetCancellationRequest$inboundSchema
   };
   tool$transfersGetCancellation = {
@@ -95409,9 +97570,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: args144,
-    tool: async (client, args145, ctx) => {
-      const [result, apiCall] = await transfersGetCancellation(client, args145.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args149,
+    tool: async (client, args150, ctx) => {
+      const [result, apiCall] = await transfersGetCancellation(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -95426,9 +97587,9 @@ var init_transfersGetCancellation2 = __esm(() => {
 
 // src/funcs/transfersGetRefund.ts
 function transfersGetRefund(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 = safeParse4(request, (value) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -95514,12 +97675,12 @@ var init_transfersGetRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersGetRefund.ts
-var args145, tool$transfersGetRefund;
+var args150, tool$transfersGetRefund;
 var init_transfersGetRefund2 = __esm(() => {
   init_transfersGetRefund();
   init_operations();
   init_tools();
-  args145 = {
+  args150 = {
     request: GetRefundRequest$inboundSchema
   };
   tool$transfersGetRefund = {
@@ -95528,9 +97689,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: args145,
-    tool: async (client, args146, ctx) => {
-      const [result, apiCall] = await transfersGetRefund(client, args146.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args150,
+    tool: async (client, args151, ctx) => {
+      const [result, apiCall] = await transfersGetRefund(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -95545,9 +97706,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersInitiateRefund.ts
 function transfersInitiateRefund(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 = safeParse4(request, (value) => InitiateRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -95639,12 +97800,12 @@ var init_transfersInitiateRefund = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersInitiateRefund.ts
-var args146, tool$transfersInitiateRefund;
+var args151, tool$transfersInitiateRefund;
 var init_transfersInitiateRefund2 = __esm(() => {
   init_transfersInitiateRefund();
   init_operations();
   init_tools();
-  args146 = {
+  args151 = {
     request: InitiateRefundRequest$inboundSchema
   };
   tool$transfersInitiateRefund = {
@@ -95656,9 +97817,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: args146,
-    tool: async (client, args147, ctx) => {
-      const [result, apiCall] = await transfersInitiateRefund(client, args147.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args151,
+    tool: async (client, args152, ctx) => {
+      const [result, apiCall] = await transfersInitiateRefund(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -95673,9 +97834,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/transfersList.ts
 function transfersList(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 = safeParse4(request, (value) => ListTransfersRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -95771,12 +97932,12 @@ var init_transfersList = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersList.ts
-var args147, tool$transfersList;
+var args152, tool$transfersList;
 var init_transfersList2 = __esm(() => {
   init_transfersList();
   init_operations();
   init_tools();
-  args147 = {
+  args152 = {
     request: ListTransfersRequest$inboundSchema
   };
   tool$transfersList = {
@@ -95792,9 +97953,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: args147,
-    tool: async (client, args148, ctx) => {
-      const [result, apiCall] = await transfersList(client, args148.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args152,
+    tool: async (client, args153, ctx) => {
+      const [result, apiCall] = await transfersList(client, args153.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -95809,9 +97970,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersListRefunds.ts
 function transfersListRefunds(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 = safeParse4(request, (value) => ListRefundsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -95893,12 +98054,12 @@ var init_transfersListRefunds = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersListRefunds.ts
-var args148, tool$transfersListRefunds;
+var args153, tool$transfersListRefunds;
 var init_transfersListRefunds2 = __esm(() => {
   init_transfersListRefunds();
   init_operations();
   init_tools();
-  args148 = {
+  args153 = {
     request: ListRefundsRequest$inboundSchema
   };
   tool$transfersListRefunds = {
@@ -95907,9 +98068,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: args148,
-    tool: async (client, args149, ctx) => {
-      const [result, apiCall] = await transfersListRefunds(client, args149.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args153,
+    tool: async (client, args154, ctx) => {
+      const [result, apiCall] = await transfersListRefunds(client, args154.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -95924,9 +98085,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.read\` scope.`,
 
 // src/funcs/transfersUpdate.ts
 function transfersUpdate(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 = safeParse4(request, (value) => UpdateTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -96012,12 +98173,12 @@ var init_transfersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/transfersUpdate.ts
-var args149, tool$transfersUpdate;
+var args154, tool$transfersUpdate;
 var init_transfersUpdate2 = __esm(() => {
   init_transfersUpdate();
   init_operations();
   init_tools();
-  args149 = {
+  args154 = {
     request: UpdateTransferRequest$inboundSchema
   };
   tool$transfersUpdate = {
@@ -96028,9 +98189,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: args149,
-    tool: async (client, args150, ctx) => {
-      const [result, apiCall] = await transfersUpdate(client, args150.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args154,
+    tool: async (client, args155, ctx) => {
+      const [result, apiCall] = await transfersUpdate(client, args155.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -96045,9 +98206,9 @@ you'll need to specify the \`/accounts/{accountID}/transfers.write\` scope.`,
 
 // src/funcs/underwritingGet.ts
 function underwritingGet(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 = safeParse4(request, (value) => GetUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -96125,12 +98286,12 @@ var init_underwritingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingGet.ts
-var args150, tool$underwritingGet;
+var args155, tool$underwritingGet;
 var init_underwritingGet2 = __esm(() => {
   init_underwritingGet();
   init_operations();
   init_tools();
-  args150 = {
+  args155 = {
     request: GetUnderwritingRequest$inboundSchema
   };
   tool$underwritingGet = {
@@ -96141,9 +98302,140 @@ 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: args150,
-    tool: async (client, args151, ctx) => {
-      const [result, apiCall] = await underwritingGet(client, args151.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args155,
+    tool: async (client, args156, ctx) => {
+      const [result, apiCall] = await underwritingGet(client, args156.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/underwritingSave.ts
+function underwritingSave(client, request, options) {
+  return new APIPromise($do156(client, request, options));
+}
+async function $do156(client, request, options) {
+  const parsed = safeParse4(request, (value) => SaveUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.UpsertUnderwriting, {
+    explode: true
+  });
+  const pathParams = {
+    accountID: encodeSimple("accountID", payload.accountID, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/accounts/{accountID}/underwriting")(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: "saveUnderwriting",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "409",
+      "422",
+      "429",
+      "4XX",
+      "500",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, SaveUnderwritingResponse$inboundSchema, {
+    hdrs: true,
+    key: "Result"
+  }), jsonErr([400, 409], GenericError$inboundSchema, { hdrs: true }), jsonErr(422, UpsertUnderwritingError$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_underwritingSave = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_errors4();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/underwritingSave.ts
+var args156, tool$underwritingSave;
+var init_underwritingSave2 = __esm(() => {
+  init_underwritingSave();
+  init_operations();
+  init_tools();
+  args156 = {
+    request: SaveUnderwritingRequest$inboundSchema
+  };
+  tool$underwritingSave = {
+    name: "underwriting-save",
+    description: `Create or update the account's underwriting.
+
+Read our [underwriting guide](https://docs.moov.io/guides/accounts/requirements/underwriting/) 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}/profile.write\` scope.`,
+    args: args156,
+    tool: async (client, args157, ctx) => {
+      const [result, apiCall] = await underwritingSave(client, args157.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -96158,9 +98450,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.read\` scope.`,
 
 // src/funcs/underwritingUpsert.ts
 function underwritingUpsert(client, request, options) {
-  return new APIPromise($do151(client, request, options));
+  return new APIPromise($do157(client, request, options));
 }
-async function $do151(client, request, options) {
+async function $do157(client, request, options) {
   const parsed = safeParse4(request, (value) => UpsertUnderwritingRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -96256,12 +98548,12 @@ var init_underwritingUpsert = __esm(() => {
 });
 
 // src/mcp-server/tools/underwritingUpsert.ts
-var args151, tool$underwritingUpsert;
+var args157, tool$underwritingUpsert;
 var init_underwritingUpsert2 = __esm(() => {
   init_underwritingUpsert();
   init_operations();
   init_tools();
-  args151 = {
+  args157 = {
     request: UpsertUnderwritingRequest$inboundSchema
   };
   tool$underwritingUpsert = {
@@ -96272,9 +98564,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: args151,
-    tool: async (client, args152, ctx) => {
-      const [result, apiCall] = await underwritingUpsert(client, args152.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args157,
+    tool: async (client, args158, ctx) => {
+      const [result, apiCall] = await underwritingUpsert(client, args158.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -96289,9 +98581,9 @@ you'll need to specify the \`/accounts/{accountID}/profile.write\` scope.`,
 
 // src/funcs/walletsCreate.ts
 function walletsCreate(client, request, options) {
-  return new APIPromise($do152(client, request, options));
+  return new APIPromise($do158(client, request, options));
 }
-async function $do152(client, request, options) {
+async function $do158(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -96385,12 +98677,12 @@ var init_walletsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsCreate.ts
-var args152, tool$walletsCreate;
+var args158, tool$walletsCreate;
 var init_walletsCreate2 = __esm(() => {
   init_walletsCreate();
   init_operations();
   init_tools();
-  args152 = {
+  args158 = {
     request: CreateWalletRequest$inboundSchema
   };
   tool$walletsCreate = {
@@ -96401,9 +98693,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: args152,
-    tool: async (client, args153, ctx) => {
-      const [result, apiCall] = await walletsCreate(client, args153.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args158,
+    tool: async (client, args159, ctx) => {
+      const [result, apiCall] = await walletsCreate(client, args159.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -96418,9 +98710,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletsGet.ts
 function walletsGet(client, request, options) {
-  return new APIPromise($do153(client, request, options));
+  return new APIPromise($do159(client, request, options));
 }
-async function $do153(client, request, options) {
+async function $do159(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -96502,12 +98794,12 @@ var init_walletsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsGet.ts
-var args153, tool$walletsGet;
+var args159, tool$walletsGet;
 var init_walletsGet2 = __esm(() => {
   init_walletsGet();
   init_operations();
   init_tools();
-  args153 = {
+  args159 = {
     request: GetWalletRequest$inboundSchema
   };
   tool$walletsGet = {
@@ -96518,9 +98810,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: args153,
-    tool: async (client, args154, ctx) => {
-      const [result, apiCall] = await walletsGet(client, args154.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args159,
+    tool: async (client, args160, ctx) => {
+      const [result, apiCall] = await walletsGet(client, args160.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -96535,9 +98827,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsList.ts
 function walletsList(client, request, options) {
-  return new APIPromise($do154(client, request, options));
+  return new APIPromise($do160(client, request, options));
 }
-async function $do154(client, request, options) {
+async function $do160(client, request, options) {
   const parsed = safeParse4(request, (value) => ListWalletsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -96625,12 +98917,12 @@ var init_walletsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsList.ts
-var args154, tool$walletsList;
+var args160, tool$walletsList;
 var init_walletsList2 = __esm(() => {
   init_walletsList();
   init_operations();
   init_tools();
-  args154 = {
+  args160 = {
     request: ListWalletsRequest$inboundSchema
   };
   tool$walletsList = {
@@ -96641,9 +98933,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: args154,
-    tool: async (client, args155, ctx) => {
-      const [result, apiCall] = await walletsList(client, args155.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args160,
+    tool: async (client, args161, ctx) => {
+      const [result, apiCall] = await walletsList(client, args161.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -96658,9 +98950,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletsUpdate.ts
 function walletsUpdate(client, request, options) {
-  return new APIPromise($do155(client, request, options));
+  return new APIPromise($do161(client, request, options));
 }
-async function $do155(client, request, options) {
+async function $do161(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateWalletRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -96758,12 +99050,12 @@ var init_walletsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsUpdate.ts
-var args155, tool$walletsUpdate;
+var args161, tool$walletsUpdate;
 var init_walletsUpdate2 = __esm(() => {
   init_walletsUpdate();
   init_operations();
   init_tools();
-  args155 = {
+  args161 = {
     request: UpdateWalletRequest$inboundSchema
   };
   tool$walletsUpdate = {
@@ -96774,9 +99066,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: args155,
-    tool: async (client, args156, ctx) => {
-      const [result, apiCall] = await walletsUpdate(client, args156.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args161,
+    tool: async (client, args162, ctx) => {
+      const [result, apiCall] = await walletsUpdate(client, args162.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -96791,9 +99083,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.write\` scope.`,
 
 // src/funcs/walletTransactionsGet.ts
 function walletTransactionsGet(client, request, options) {
-  return new APIPromise($do156(client, request, options));
+  return new APIPromise($do162(client, request, options));
 }
-async function $do156(client, request, options) {
+async function $do162(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWalletTransactionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -96879,12 +99171,12 @@ var init_walletTransactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsGet.ts
-var args156, tool$walletTransactionsGet;
+var args162, tool$walletTransactionsGet;
 var init_walletTransactionsGet2 = __esm(() => {
   init_walletTransactionsGet();
   init_operations();
   init_tools();
-  args156 = {
+  args162 = {
     request: GetWalletTransactionRequest$inboundSchema
   };
   tool$walletTransactionsGet = {
@@ -96895,9 +99187,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: args156,
-    tool: async (client, args157, ctx) => {
-      const [result, apiCall] = await walletTransactionsGet(client, args157.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args162,
+    tool: async (client, args163, ctx) => {
+      const [result, apiCall] = await walletTransactionsGet(client, args163.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -96912,9 +99204,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/walletTransactionsList.ts
 function walletTransactionsList(client, request, options) {
-  return new APIPromise($do157(client, request, options));
+  return new APIPromise($do163(client, request, options));
 }
-async function $do157(client, request, options) {
+async function $do163(client, request, options) {
   const parsed = safeParse4(request, (value) => ListWalletTransactionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97014,12 +99306,12 @@ var init_walletTransactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/walletTransactionsList.ts
-var args157, tool$walletTransactionsList;
+var args163, tool$walletTransactionsList;
 var init_walletTransactionsList2 = __esm(() => {
   init_walletTransactionsList();
   init_operations();
   init_tools();
-  args157 = {
+  args163 = {
     request: ListWalletTransactionsRequest$inboundSchema
   };
   tool$walletTransactionsList = {
@@ -97030,9 +99322,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: args157,
-    tool: async (client, args158, ctx) => {
-      const [result, apiCall] = await walletTransactionsList(client, args158.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args163,
+    tool: async (client, args164, ctx) => {
+      const [result, apiCall] = await walletTransactionsList(client, args164.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97047,9 +99339,9 @@ you'll need to specify the \`/accounts/{accountID}/wallets.read\` scope.`,
 
 // src/funcs/webhooksCreate.ts
 function webhooksCreate(client, request, options) {
-  return new APIPromise($do158(client, request, options));
+  return new APIPromise($do164(client, request, options));
 }
-async function $do158(client, request, options) {
+async function $do164(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateWebhook$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97138,20 +99430,20 @@ var init_webhooksCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksCreate.ts
-var args158, tool$webhooksCreate;
+var args164, tool$webhooksCreate;
 var init_webhooksCreate2 = __esm(() => {
   init_webhooksCreate();
   init_components();
   init_tools();
-  args158 = {
+  args164 = {
     request: CreateWebhook$inboundSchema
   };
   tool$webhooksCreate = {
     name: "webhooks-create",
     description: `Create a new webhook for the account.`,
-    args: args158,
-    tool: async (client, args159, ctx) => {
-      const [result, apiCall] = await webhooksCreate(client, args159.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args164,
+    tool: async (client, args165, ctx) => {
+      const [result, apiCall] = await webhooksCreate(client, args165.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97166,9 +99458,9 @@ var init_webhooksCreate2 = __esm(() => {
 
 // src/funcs/webhooksDisable.ts
 function webhooksDisable(client, request, options) {
-  return new APIPromise($do159(client, request, options));
+  return new APIPromise($do165(client, request, options));
 }
-async function $do159(client, request, options) {
+async function $do165(client, request, options) {
   const parsed = safeParse4(request, (value) => DisableWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97257,20 +99549,20 @@ var init_webhooksDisable = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksDisable.ts
-var args159, tool$webhooksDisable;
+var args165, tool$webhooksDisable;
 var init_webhooksDisable2 = __esm(() => {
   init_webhooksDisable();
   init_operations();
   init_tools();
-  args159 = {
+  args165 = {
     request: DisableWebhookRequest$inboundSchema
   };
   tool$webhooksDisable = {
     name: "webhooks-disable",
     description: `Disable a webhook. Disabled webhooks will no longer receive events.`,
-    args: args159,
-    tool: async (client, args160, ctx) => {
-      const [result, apiCall] = await webhooksDisable(client, args160.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args165,
+    tool: async (client, args166, ctx) => {
+      const [result, apiCall] = await webhooksDisable(client, args166.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97284,9 +99576,9 @@ var init_webhooksDisable2 = __esm(() => {
 
 // src/funcs/webhooksGet.ts
 function webhooksGet(client, request, options) {
-  return new APIPromise($do160(client, request, options));
+  return new APIPromise($do166(client, request, options));
 }
-async function $do160(client, request, options) {
+async function $do166(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97364,20 +99656,20 @@ var init_webhooksGet = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksGet.ts
-var args160, tool$webhooksGet;
+var args166, tool$webhooksGet;
 var init_webhooksGet2 = __esm(() => {
   init_webhooksGet();
   init_operations();
   init_tools();
-  args160 = {
+  args166 = {
     request: GetWebhookRequest$inboundSchema
   };
   tool$webhooksGet = {
     name: "webhooks-get",
     description: `Get details of a specific webhook.`,
-    args: args160,
-    tool: async (client, args161, ctx) => {
-      const [result, apiCall] = await webhooksGet(client, args161.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args166,
+    tool: async (client, args167, ctx) => {
+      const [result, apiCall] = await webhooksGet(client, args167.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97392,9 +99684,9 @@ var init_webhooksGet2 = __esm(() => {
 
 // src/funcs/webhooksGetSecret.ts
 function webhooksGetSecret(client, request, options) {
-  return new APIPromise($do161(client, request, options));
+  return new APIPromise($do167(client, request, options));
 }
-async function $do161(client, request, options) {
+async function $do167(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWebhookSecretRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97472,20 +99764,20 @@ var init_webhooksGetSecret = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksGetSecret.ts
-var args161, tool$webhooksGetSecret;
+var args167, tool$webhooksGetSecret;
 var init_webhooksGetSecret2 = __esm(() => {
   init_webhooksGetSecret();
   init_operations();
   init_tools();
-  args161 = {
+  args167 = {
     request: GetWebhookSecretRequest$inboundSchema
   };
   tool$webhooksGetSecret = {
     name: "webhooks-get-secret",
     description: `Get the secret key for verifying webhook payloads.`,
-    args: args161,
-    tool: async (client, args162, ctx) => {
-      const [result, apiCall] = await webhooksGetSecret(client, args162.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args167,
+    tool: async (client, args168, ctx) => {
+      const [result, apiCall] = await webhooksGetSecret(client, args168.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97500,9 +99792,9 @@ var init_webhooksGetSecret2 = __esm(() => {
 
 // src/funcs/webhooksList.ts
 function webhooksList(client, _request, options) {
-  return new APIPromise($do162(client, _request, options));
+  return new APIPromise($do168(client, _request, options));
 }
-async function $do162(client, _request, options) {
+async function $do168(client, _request, options) {
   const path = pathToFunc("/webhooks")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -97566,20 +99858,20 @@ var init_webhooksList = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksList.ts
-var args162, tool$webhooksList;
+var args168, tool$webhooksList;
 var init_webhooksList2 = __esm(() => {
   init_webhooksList();
   init_operations();
   init_tools();
-  args162 = {
+  args168 = {
     request: ListWebhooksRequest$inboundSchema
   };
   tool$webhooksList = {
     name: "webhooks-list",
     description: `List all webhooks configured for the account.`,
-    args: args162,
-    tool: async (client, args163, ctx) => {
-      const [result, apiCall] = await webhooksList(client, args163.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args168,
+    tool: async (client, args169, ctx) => {
+      const [result, apiCall] = await webhooksList(client, args169.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97594,9 +99886,9 @@ var init_webhooksList2 = __esm(() => {
 
 // src/funcs/webhooksListEventTypes.ts
 function webhooksListEventTypes(client, _request, options) {
-  return new APIPromise($do163(client, _request, options));
+  return new APIPromise($do169(client, _request, options));
 }
-async function $do163(client, _request, options) {
+async function $do169(client, _request, options) {
   const path = pathToFunc("/event-types")();
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -97660,20 +99952,20 @@ var init_webhooksListEventTypes = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksListEventTypes.ts
-var args163, tool$webhooksListEventTypes;
+var args169, tool$webhooksListEventTypes;
 var init_webhooksListEventTypes2 = __esm(() => {
   init_webhooksListEventTypes();
   init_operations();
   init_tools();
-  args163 = {
+  args169 = {
     request: ListEventTypesRequest$inboundSchema
   };
   tool$webhooksListEventTypes = {
     name: "webhooks-list-event-types",
     description: `List all available event types that can be subscribed to.`,
-    args: args163,
-    tool: async (client, args164, ctx) => {
-      const [result, apiCall] = await webhooksListEventTypes(client, args164.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args169,
+    tool: async (client, args170, ctx) => {
+      const [result, apiCall] = await webhooksListEventTypes(client, args170.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97688,9 +99980,9 @@ var init_webhooksListEventTypes2 = __esm(() => {
 
 // src/funcs/webhooksPing.ts
 function webhooksPing(client, request, options) {
-  return new APIPromise($do164(client, request, options));
+  return new APIPromise($do170(client, request, options));
 }
-async function $do164(client, request, options) {
+async function $do170(client, request, options) {
   const parsed = safeParse4(request, (value) => PingWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97768,20 +100060,20 @@ var init_webhooksPing = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksPing.ts
-var args164, tool$webhooksPing;
+var args170, tool$webhooksPing;
 var init_webhooksPing2 = __esm(() => {
   init_webhooksPing();
   init_operations();
   init_tools();
-  args164 = {
+  args170 = {
     request: PingWebhookRequest$inboundSchema
   };
   tool$webhooksPing = {
     name: "webhooks-ping",
     description: `Send a test ping to a webhook to verify it is configured correctly.`,
-    args: args164,
-    tool: async (client, args165, ctx) => {
-      const [result, apiCall] = await webhooksPing(client, args165.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args170,
+    tool: async (client, args171, ctx) => {
+      const [result, apiCall] = await webhooksPing(client, args171.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97796,9 +100088,9 @@ var init_webhooksPing2 = __esm(() => {
 
 // src/funcs/webhooksUpdate.ts
 function webhooksUpdate(client, request, options) {
-  return new APIPromise($do165(client, request, options));
+  return new APIPromise($do171(client, request, options));
 }
-async function $do165(client, request, options) {
+async function $do171(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -97892,20 +100184,20 @@ var init_webhooksUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksUpdate.ts
-var args165, tool$webhooksUpdate;
+var args171, tool$webhooksUpdate;
 var init_webhooksUpdate2 = __esm(() => {
   init_webhooksUpdate();
   init_operations();
   init_tools();
-  args165 = {
+  args171 = {
     request: UpdateWebhookRequest$inboundSchema
   };
   tool$webhooksUpdate = {
     name: "webhooks-update",
     description: `Update an existing webhook.`,
-    args: args165,
-    tool: async (client, args166, ctx) => {
-      const [result, apiCall] = await webhooksUpdate(client, args166.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args171,
+    tool: async (client, args172, ctx) => {
+      const [result, apiCall] = await webhooksUpdate(client, args172.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -97922,7 +100214,7 @@ var init_webhooksUpdate2 = __esm(() => {
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Moov",
-    version: "25.1.1"
+    version: "25.7.0"
   });
   const client = new MoovCore({
     security: deps.security,
@@ -98043,6 +100335,11 @@ function createMCPServer(deps) {
   tool(tool$accountTerminalApplicationsList);
   tool(tool$accountTerminalApplicationsGet);
   tool(tool$accountTerminalApplicationsGetConfiguration);
+  tool(tool$supportCreateTicket);
+  tool(tool$supportListTickets);
+  tool(tool$supportGetTicket);
+  tool(tool$supportUpdateTicket);
+  tool(tool$supportListTicketMessages);
   tool(tool$transfersGenerateOptions);
   tool(tool$transfersCreate);
   tool(tool$transfersList);
@@ -98055,6 +100352,7 @@ function createMCPServer(deps) {
   tool(tool$transfersGetRefund);
   tool(tool$transfersCreateReversal);
   tool(tool$underwritingGet);
+  tool(tool$underwritingSave);
   tool(tool$underwritingUpsert);
   tool(tool$walletsCreate);
   tool(tool$walletsList);
@@ -98236,6 +100534,11 @@ var init_server2 = __esm(() => {
   init_schedulingUpdate2();
   init_statementsGet2();
   init_statementsList2();
+  init_supportCreateTicket2();
+  init_supportGetTicket2();
+  init_supportListTicketMessages2();
+  init_supportListTickets2();
+  init_supportUpdateTicket2();
   init_sweepsCreateConfig2();
   init_sweepsGet2();
   init_sweepsGetConfig2();
@@ -98259,6 +100562,7 @@ var init_server2 = __esm(() => {
   init_transfersListRefunds2();
   init_transfersUpdate2();
   init_underwritingGet2();
+  init_underwritingSave2();
   init_underwritingUpsert2();
   init_walletsCreate2();
   init_walletsGet2();
@@ -99476,7 +101780,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "25.1.1"
+    currentVersion: "25.7.0"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -99484,5 +101788,5 @@ export {
   app
 };
 
-//# debugId=25F4961CC34359C064756E2164756E21
+//# debugId=65F5F4DE937537EE64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map