mollie-api-typescript 0.2.9 → 0.3.0

package/bin/mcp-server.js

@@ -34295,9 +34295,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.2.9",
-    genVersion: "2.716.16",
-    userAgent: "speakeasy-sdk/typescript 0.2.9 2.716.16 1.0.0 mollie-api-typescript"
+    sdkVersion: "0.3.0",
+    genVersion: "2.722.2",
+    userAgent: "speakeasy-sdk/typescript 0.3.0 2.722.2 1.0.0 mollie-api-typescript"
   };
 });
 
@@ -35941,6 +35941,56 @@ var init_balancetransactiontype = __esm(() => {
   })(BalanceTransactionType$ ||= {});
 });
 
+// src/models/balancetransfercategory.ts
+var BalanceTransferCategory, BalanceTransferCategory$inboundSchema, BalanceTransferCategory$outboundSchema, BalanceTransferCategory$;
+var init_balancetransfercategory = __esm(() => {
+  init_esm();
+  BalanceTransferCategory = {
+    InvoiceCollection: "invoice_collection",
+    Purchase: "purchase",
+    Chargeback: "chargeback",
+    Refund: "refund",
+    ServicePenalty: "service_penalty",
+    DiscountCompensation: "discount_compensation",
+    ManualCorrection: "manual_correction",
+    Fee: "fee"
+  };
+  BalanceTransferCategory$inboundSchema = nativeEnumType(BalanceTransferCategory);
+  BalanceTransferCategory$outboundSchema = BalanceTransferCategory$inboundSchema;
+  ((BalanceTransferCategory$) => {
+    BalanceTransferCategory$.inboundSchema = BalanceTransferCategory$inboundSchema;
+    BalanceTransferCategory$.outboundSchema = BalanceTransferCategory$outboundSchema;
+  })(BalanceTransferCategory$ ||= {});
+});
+
+// src/models/balancetransfercategoryresponse.ts
+var BalanceTransferCategoryResponse, BalanceTransferCategoryResponse$inboundSchema, BalanceTransferCategoryResponse$outboundSchema, BalanceTransferCategoryResponse$;
+var init_balancetransfercategoryresponse = __esm(() => {
+  init_esm();
+  BalanceTransferCategoryResponse = {
+    InvoiceCollection: "invoice_collection",
+    Purchase: "purchase",
+    Chargeback: "chargeback",
+    Refund: "refund",
+    ServicePenalty: "service_penalty",
+    DiscountCompensation: "discount_compensation",
+    ManualCorrection: "manual_correction",
+    Fee: "fee"
+  };
+  BalanceTransferCategoryResponse$inboundSchema = unionType([
+    nativeEnumType(BalanceTransferCategoryResponse),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  BalanceTransferCategoryResponse$outboundSchema = unionType([
+    nativeEnumType(BalanceTransferCategoryResponse),
+    stringType().and(custom())
+  ]);
+  ((BalanceTransferCategoryResponse$) => {
+    BalanceTransferCategoryResponse$.inboundSchema = BalanceTransferCategoryResponse$inboundSchema;
+    BalanceTransferCategoryResponse$.outboundSchema = BalanceTransferCategoryResponse$outboundSchema;
+  })(BalanceTransferCategoryResponse$ ||= {});
+});
+
 // src/models/balancetransferdestinationtype.ts
 var BalanceTransferDestinationType, BalanceTransferDestinationType$inboundSchema, BalanceTransferDestinationType$outboundSchema, BalanceTransferDestinationType$;
 var init_balancetransferdestinationtype = __esm(() => {
@@ -35990,6 +36040,94 @@ var init_balancetransferfrequency = __esm(() => {
   })(BalanceTransferFrequency$ ||= {});
 });
 
+// src/models/balancetransferpartytype.ts
+var BalanceTransferPartyType, BalanceTransferPartyType$inboundSchema, BalanceTransferPartyType$outboundSchema, BalanceTransferPartyType$;
+var init_balancetransferpartytype = __esm(() => {
+  init_esm();
+  BalanceTransferPartyType = {
+    Organization: "organization"
+  };
+  BalanceTransferPartyType$inboundSchema = nativeEnumType(BalanceTransferPartyType);
+  BalanceTransferPartyType$outboundSchema = BalanceTransferPartyType$inboundSchema;
+  ((BalanceTransferPartyType$) => {
+    BalanceTransferPartyType$.inboundSchema = BalanceTransferPartyType$inboundSchema;
+    BalanceTransferPartyType$.outboundSchema = BalanceTransferPartyType$outboundSchema;
+  })(BalanceTransferPartyType$ ||= {});
+});
+
+// src/models/balancetransferpartytyperesponse.ts
+var BalanceTransferPartyTypeResponse, BalanceTransferPartyTypeResponse$inboundSchema, BalanceTransferPartyTypeResponse$outboundSchema, BalanceTransferPartyTypeResponse$;
+var init_balancetransferpartytyperesponse = __esm(() => {
+  init_esm();
+  BalanceTransferPartyTypeResponse = {
+    Organization: "organization"
+  };
+  BalanceTransferPartyTypeResponse$inboundSchema = unionType([
+    nativeEnumType(BalanceTransferPartyTypeResponse),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  BalanceTransferPartyTypeResponse$outboundSchema = unionType([
+    nativeEnumType(BalanceTransferPartyTypeResponse),
+    stringType().and(custom())
+  ]);
+  ((BalanceTransferPartyTypeResponse$) => {
+    BalanceTransferPartyTypeResponse$.inboundSchema = BalanceTransferPartyTypeResponse$inboundSchema;
+    BalanceTransferPartyTypeResponse$.outboundSchema = BalanceTransferPartyTypeResponse$outboundSchema;
+  })(BalanceTransferPartyTypeResponse$ ||= {});
+});
+
+// src/models/balancetransferstatus.ts
+var BalanceTransferStatus, BalanceTransferStatus$inboundSchema, BalanceTransferStatus$outboundSchema, BalanceTransferStatus$;
+var init_balancetransferstatus = __esm(() => {
+  init_esm();
+  BalanceTransferStatus = {
+    Created: "created",
+    Failed: "failed",
+    Succeeded: "succeeded"
+  };
+  BalanceTransferStatus$inboundSchema = unionType([
+    nativeEnumType(BalanceTransferStatus),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  BalanceTransferStatus$outboundSchema = unionType([
+    nativeEnumType(BalanceTransferStatus),
+    stringType().and(custom())
+  ]);
+  ((BalanceTransferStatus$) => {
+    BalanceTransferStatus$.inboundSchema = BalanceTransferStatus$inboundSchema;
+    BalanceTransferStatus$.outboundSchema = BalanceTransferStatus$outboundSchema;
+  })(BalanceTransferStatus$ ||= {});
+});
+
+// src/models/balancetransferstatusreasonresponse.ts
+var BalanceTransferStatusReasonResponse, BalanceTransferStatusReasonResponse$inboundSchema, BalanceTransferStatusReasonResponse$outboundSchema, BalanceTransferStatusReasonResponse$;
+var init_balancetransferstatusreasonresponse = __esm(() => {
+  init_esm();
+  BalanceTransferStatusReasonResponse = {
+    RequestCreated: "request_created",
+    Success: "success",
+    SourceNotAllowed: "source_not_allowed",
+    DestinationNotAllowed: "destination_not_allowed",
+    InsufficientFunds: "insufficient_funds",
+    InvalidSourceBalance: "invalid_source_balance",
+    InvalidDestinationBalance: "invalid_destination_balance",
+    TransferRequestExpired: "transfer_request_expired",
+    TransferLimitReached: "transfer_limit_reached"
+  };
+  BalanceTransferStatusReasonResponse$inboundSchema = unionType([
+    nativeEnumType(BalanceTransferStatusReasonResponse),
+    stringType().transform(catchUnrecognizedEnum)
+  ]);
+  BalanceTransferStatusReasonResponse$outboundSchema = unionType([
+    nativeEnumType(BalanceTransferStatusReasonResponse),
+    stringType().and(custom())
+  ]);
+  ((BalanceTransferStatusReasonResponse$) => {
+    BalanceTransferStatusReasonResponse$.inboundSchema = BalanceTransferStatusReasonResponse$inboundSchema;
+    BalanceTransferStatusReasonResponse$.outboundSchema = BalanceTransferStatusReasonResponse$outboundSchema;
+  })(BalanceTransferStatusReasonResponse$ ||= {});
+});
+
 // src/models/capabilityrequirementstatus.ts
 var CapabilityRequirementStatus, CapabilityRequirementStatus$inboundSchema, CapabilityRequirementStatus$outboundSchema, CapabilityRequirementStatus$;
 var init_capabilityrequirementstatus = __esm(() => {
@@ -36712,9 +36850,11 @@ var init_createwebhook = __esm(() => {
   init_webhookeventtypes();
   init_webhookstatus();
   CreateWebhookLinks$inboundSchema = objectType({
+    self: Url$inboundSchema,
     documentation: Url$inboundSchema
   });
   CreateWebhookLinks$outboundSchema = objectType({
+    self: Url$outboundSchema,
     documentation: Url$outboundSchema
   });
   ((CreateWebhookLinks$) => {
@@ -37881,6 +38021,135 @@ var init_entitybalancetransaction = __esm(() => {
   })(EntityBalanceTransaction$ ||= {});
 });
 
+// src/models/entitybalancetransferparty.ts
+var EntityBalanceTransferParty$inboundSchema, EntityBalanceTransferParty$outboundSchema, EntityBalanceTransferParty$;
+var init_entitybalancetransferparty = __esm(() => {
+  init_esm();
+  init_balancetransferpartytype();
+  EntityBalanceTransferParty$inboundSchema = objectType({
+    type: BalanceTransferPartyType$inboundSchema,
+    id: stringType(),
+    description: stringType()
+  });
+  EntityBalanceTransferParty$outboundSchema = objectType({
+    type: BalanceTransferPartyType$outboundSchema,
+    id: stringType(),
+    description: stringType()
+  });
+  ((EntityBalanceTransferParty$) => {
+    EntityBalanceTransferParty$.inboundSchema = EntityBalanceTransferParty$inboundSchema;
+    EntityBalanceTransferParty$.outboundSchema = EntityBalanceTransferParty$outboundSchema;
+  })(EntityBalanceTransferParty$ ||= {});
+});
+
+// src/models/entitybalancetransfer.ts
+var EntityBalanceTransfer$inboundSchema, EntityBalanceTransfer$outboundSchema, EntityBalanceTransfer$;
+var init_entitybalancetransfer = __esm(() => {
+  init_esm();
+  init_amount();
+  init_balancetransfercategory();
+  init_entitybalancetransferparty();
+  EntityBalanceTransfer$inboundSchema = objectType({
+    id: stringType(),
+    amount: Amount$inboundSchema,
+    source: EntityBalanceTransferParty$inboundSchema,
+    destination: EntityBalanceTransferParty$inboundSchema,
+    description: stringType(),
+    category: BalanceTransferCategory$inboundSchema.optional(),
+    testmode: nullableType(booleanType()).optional()
+  });
+  EntityBalanceTransfer$outboundSchema = objectType({
+    id: stringType(),
+    amount: Amount$outboundSchema,
+    source: EntityBalanceTransferParty$outboundSchema,
+    destination: EntityBalanceTransferParty$outboundSchema,
+    description: stringType(),
+    category: BalanceTransferCategory$outboundSchema.optional(),
+    testmode: nullableType(booleanType()).optional()
+  });
+  ((EntityBalanceTransfer$) => {
+    EntityBalanceTransfer$.inboundSchema = EntityBalanceTransfer$inboundSchema;
+    EntityBalanceTransfer$.outboundSchema = EntityBalanceTransfer$outboundSchema;
+  })(EntityBalanceTransfer$ ||= {});
+});
+
+// src/models/entitybalancetransferpartyresponse.ts
+var EntityBalanceTransferPartyResponse$inboundSchema, EntityBalanceTransferPartyResponse$outboundSchema, EntityBalanceTransferPartyResponse$;
+var init_entitybalancetransferpartyresponse = __esm(() => {
+  init_esm();
+  init_balancetransferpartytyperesponse();
+  EntityBalanceTransferPartyResponse$inboundSchema = objectType({
+    type: BalanceTransferPartyTypeResponse$inboundSchema,
+    id: stringType(),
+    description: stringType()
+  });
+  EntityBalanceTransferPartyResponse$outboundSchema = objectType({
+    type: BalanceTransferPartyTypeResponse$outboundSchema,
+    id: stringType(),
+    description: stringType()
+  });
+  ((EntityBalanceTransferPartyResponse$) => {
+    EntityBalanceTransferPartyResponse$.inboundSchema = EntityBalanceTransferPartyResponse$inboundSchema;
+    EntityBalanceTransferPartyResponse$.outboundSchema = EntityBalanceTransferPartyResponse$outboundSchema;
+  })(EntityBalanceTransferPartyResponse$ ||= {});
+});
+
+// src/models/entitybalancetransferresponse.ts
+var EntityBalanceTransferResponseStatusReason$inboundSchema, EntityBalanceTransferResponseStatusReason$outboundSchema, EntityBalanceTransferResponseStatusReason$, EntityBalanceTransferResponse$inboundSchema, EntityBalanceTransferResponse$outboundSchema, EntityBalanceTransferResponse$;
+var init_entitybalancetransferresponse = __esm(() => {
+  init_esm();
+  init_amount();
+  init_balancetransfercategoryresponse();
+  init_balancetransferstatus();
+  init_balancetransferstatusreasonresponse();
+  init_entitybalancetransferpartyresponse();
+  init_mode();
+  EntityBalanceTransferResponseStatusReason$inboundSchema = objectType({
+    code: BalanceTransferStatusReasonResponse$inboundSchema,
+    message: stringType()
+  });
+  EntityBalanceTransferResponseStatusReason$outboundSchema = objectType({
+    code: BalanceTransferStatusReasonResponse$outboundSchema,
+    message: stringType()
+  });
+  ((EntityBalanceTransferResponseStatusReason$) => {
+    EntityBalanceTransferResponseStatusReason$.inboundSchema = EntityBalanceTransferResponseStatusReason$inboundSchema;
+    EntityBalanceTransferResponseStatusReason$.outboundSchema = EntityBalanceTransferResponseStatusReason$outboundSchema;
+  })(EntityBalanceTransferResponseStatusReason$ ||= {});
+  EntityBalanceTransferResponse$inboundSchema = objectType({
+    resource: stringType(),
+    id: stringType(),
+    amount: Amount$inboundSchema,
+    source: EntityBalanceTransferPartyResponse$inboundSchema,
+    destination: EntityBalanceTransferPartyResponse$inboundSchema,
+    description: stringType(),
+    status: BalanceTransferStatus$inboundSchema,
+    statusReason: lazyType(() => EntityBalanceTransferResponseStatusReason$inboundSchema),
+    category: BalanceTransferCategoryResponse$inboundSchema.optional(),
+    createdAt: stringType(),
+    executedAt: nullableType(stringType()).optional(),
+    mode: Mode$inboundSchema
+  });
+  EntityBalanceTransferResponse$outboundSchema = objectType({
+    resource: stringType(),
+    id: stringType(),
+    amount: Amount$outboundSchema,
+    source: EntityBalanceTransferPartyResponse$outboundSchema,
+    destination: EntityBalanceTransferPartyResponse$outboundSchema,
+    description: stringType(),
+    status: BalanceTransferStatus$outboundSchema,
+    statusReason: lazyType(() => EntityBalanceTransferResponseStatusReason$outboundSchema),
+    category: BalanceTransferCategoryResponse$outboundSchema.optional(),
+    createdAt: stringType(),
+    executedAt: nullableType(stringType()).optional(),
+    mode: Mode$outboundSchema
+  });
+  ((EntityBalanceTransferResponse$) => {
+    EntityBalanceTransferResponse$.inboundSchema = EntityBalanceTransferResponse$inboundSchema;
+    EntityBalanceTransferResponse$.outboundSchema = EntityBalanceTransferResponse$outboundSchema;
+  })(EntityBalanceTransferResponse$ ||= {});
+});
+
 // src/models/entitycapabilityrequirement.ts
 var Dashboard$inboundSchema, Dashboard$outboundSchema, Dashboard$, EntityCapabilityRequirementLinks$inboundSchema, EntityCapabilityRequirementLinks$outboundSchema, EntityCapabilityRequirementLinks$, EntityCapabilityRequirement$inboundSchema, EntityCapabilityRequirement$outboundSchema, EntityCapabilityRequirement$;
 var init_entitycapabilityrequirement = __esm(() => {
@@ -40622,9 +40891,11 @@ var init_entitywebhook = __esm(() => {
   init_webhookeventtypes();
   init_webhookstatus();
   EntityWebhookLinks$inboundSchema = objectType({
+    self: Url$inboundSchema,
     documentation: Url$inboundSchema
   });
   EntityWebhookLinks$outboundSchema = objectType({
+    self: Url$outboundSchema,
     documentation: Url$outboundSchema
   });
   ((EntityWebhookLinks$) => {
@@ -42985,8 +43256,14 @@ var init_models = __esm(() => {
   init_balancereportgrouping();
   init_balancestatus();
   init_balancetransactiontype();
+  init_balancetransfercategory();
+  init_balancetransfercategoryresponse();
   init_balancetransferdestinationtype();
   init_balancetransferfrequency();
+  init_balancetransferpartytype();
+  init_balancetransferpartytyperesponse();
+  init_balancetransferstatus();
+  init_balancetransferstatusreasonresponse();
   init_capabilityrequirementstatus();
   init_capabilitystatus();
   init_capabilitystatusreason();
@@ -43002,6 +43279,10 @@ var init_models = __esm(() => {
   init_entitybalance();
   init_entitybalancereport();
   init_entitybalancetransaction();
+  init_entitybalancetransfer();
+  init_entitybalancetransferparty();
+  init_entitybalancetransferpartyresponse();
+  init_entitybalancetransferresponse();
   init_entitycapability();
   init_entitycapabilityrequirement();
   init_entitycapture();
@@ -43381,6 +43662,36 @@ var init_createclientlink = __esm(() => {
   })(CreateClientLinkRequest$ ||= {});
 });
 
+// src/models/operations/createconnectbalancetransfer.ts
+var CreateConnectBalanceTransferRequest$inboundSchema, CreateConnectBalanceTransferRequest$outboundSchema, CreateConnectBalanceTransferRequest$;
+var init_createconnectbalancetransfer = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_models();
+  CreateConnectBalanceTransferRequest$inboundSchema = objectType({
+    "idempotency-key": stringType().optional(),
+    "entity-balance-transfer": EntityBalanceTransfer$inboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "idempotency-key": "idempotencyKey",
+      "entity-balance-transfer": "entityBalanceTransfer"
+    });
+  });
+  CreateConnectBalanceTransferRequest$outboundSchema = objectType({
+    idempotencyKey: stringType().optional(),
+    entityBalanceTransfer: EntityBalanceTransfer$outboundSchema.optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      idempotencyKey: "idempotency-key",
+      entityBalanceTransfer: "entity-balance-transfer"
+    });
+  });
+  ((CreateConnectBalanceTransferRequest$) => {
+    CreateConnectBalanceTransferRequest$.inboundSchema = CreateConnectBalanceTransferRequest$inboundSchema;
+    CreateConnectBalanceTransferRequest$.outboundSchema = CreateConnectBalanceTransferRequest$outboundSchema;
+  })(CreateConnectBalanceTransferRequest$ ||= {});
+});
+
 // src/models/operations/createcustomer.ts
 var CreateCustomerRequest$inboundSchema, CreateCustomerRequest$outboundSchema, CreateCustomerRequest$;
 var init_createcustomer = __esm(() => {
@@ -44191,6 +44502,35 @@ var init_getclient = __esm(() => {
   })(GetClientResponse$ ||= {});
 });
 
+// src/models/operations/getconnectbalancetransfer.ts
+var GetConnectBalanceTransferRequest$inboundSchema, GetConnectBalanceTransferRequest$outboundSchema, GetConnectBalanceTransferRequest$;
+var init_getconnectbalancetransfer = __esm(() => {
+  init_esm();
+  init_primitives();
+  GetConnectBalanceTransferRequest$inboundSchema = objectType({
+    id: stringType(),
+    testmode: nullableType(booleanType()).optional(),
+    "idempotency-key": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "idempotency-key": "idempotencyKey"
+    });
+  });
+  GetConnectBalanceTransferRequest$outboundSchema = objectType({
+    id: stringType(),
+    testmode: nullableType(booleanType()).optional(),
+    idempotencyKey: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      idempotencyKey: "idempotency-key"
+    });
+  });
+  ((GetConnectBalanceTransferRequest$) => {
+    GetConnectBalanceTransferRequest$.inboundSchema = GetConnectBalanceTransferRequest$inboundSchema;
+    GetConnectBalanceTransferRequest$.outboundSchema = GetConnectBalanceTransferRequest$outboundSchema;
+  })(GetConnectBalanceTransferRequest$ ||= {});
+});
+
 // src/models/operations/getcurrentorganization.ts
 var GetCurrentOrganizationRequest$inboundSchema, GetCurrentOrganizationRequest$outboundSchema, GetCurrentOrganizationRequest$;
 var init_getcurrentorganization = __esm(() => {
@@ -45848,6 +46188,82 @@ var init_listclients = __esm(() => {
   })(ListClientsResponse$ ||= {});
 });
 
+// src/models/operations/listconnectbalancetransfers.ts
+var ListConnectBalanceTransfersRequest$inboundSchema, ListConnectBalanceTransfersRequest$outboundSchema, ListConnectBalanceTransfersRequest$, ListConnectBalanceTransfersEmbedded$inboundSchema, ListConnectBalanceTransfersEmbedded$outboundSchema, ListConnectBalanceTransfersEmbedded$, ListConnectBalanceTransfersResponse$inboundSchema, ListConnectBalanceTransfersResponse$outboundSchema, ListConnectBalanceTransfersResponse$;
+var init_listconnectbalancetransfers = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_models();
+  ListConnectBalanceTransfersRequest$inboundSchema = objectType({
+    from: nullableType(stringType()).optional(),
+    limit: nullableType(numberType().int()).optional(),
+    sort: nullableType(ListSort$inboundSchema).optional(),
+    testmode: nullableType(booleanType()).optional(),
+    "idempotency-key": stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      "idempotency-key": "idempotencyKey"
+    });
+  });
+  ListConnectBalanceTransfersRequest$outboundSchema = objectType({
+    from: nullableType(stringType()).optional(),
+    limit: nullableType(numberType().int()).optional(),
+    sort: nullableType(ListSort$outboundSchema).optional(),
+    testmode: nullableType(booleanType()).optional(),
+    idempotencyKey: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      idempotencyKey: "idempotency-key"
+    });
+  });
+  ((ListConnectBalanceTransfersRequest$) => {
+    ListConnectBalanceTransfersRequest$.inboundSchema = ListConnectBalanceTransfersRequest$inboundSchema;
+    ListConnectBalanceTransfersRequest$.outboundSchema = ListConnectBalanceTransfersRequest$outboundSchema;
+  })(ListConnectBalanceTransfersRequest$ ||= {});
+  ListConnectBalanceTransfersEmbedded$inboundSchema = objectType({
+    connect_balance_transfers: arrayType(EntityBalanceTransferResponse$inboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      connect_balance_transfers: "connectBalanceTransfers"
+    });
+  });
+  ListConnectBalanceTransfersEmbedded$outboundSchema = objectType({
+    connectBalanceTransfers: arrayType(EntityBalanceTransferResponse$outboundSchema)
+  }).transform((v2) => {
+    return remap(v2, {
+      connectBalanceTransfers: "connect_balance_transfers"
+    });
+  });
+  ((ListConnectBalanceTransfersEmbedded$) => {
+    ListConnectBalanceTransfersEmbedded$.inboundSchema = ListConnectBalanceTransfersEmbedded$inboundSchema;
+    ListConnectBalanceTransfersEmbedded$.outboundSchema = ListConnectBalanceTransfersEmbedded$outboundSchema;
+  })(ListConnectBalanceTransfersEmbedded$ ||= {});
+  ListConnectBalanceTransfersResponse$inboundSchema = objectType({
+    count: numberType().int(),
+    _embedded: lazyType(() => ListConnectBalanceTransfersEmbedded$inboundSchema),
+    _links: ListLinks$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      _embedded: "embedded",
+      _links: "links"
+    });
+  });
+  ListConnectBalanceTransfersResponse$outboundSchema = objectType({
+    count: numberType().int(),
+    embedded: lazyType(() => ListConnectBalanceTransfersEmbedded$outboundSchema),
+    links: ListLinks$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      embedded: "_embedded",
+      links: "_links"
+    });
+  });
+  ((ListConnectBalanceTransfersResponse$) => {
+    ListConnectBalanceTransfersResponse$.inboundSchema = ListConnectBalanceTransfersResponse$inboundSchema;
+    ListConnectBalanceTransfersResponse$.outboundSchema = ListConnectBalanceTransfersResponse$outboundSchema;
+  })(ListConnectBalanceTransfersResponse$ ||= {});
+});
+
 // src/models/operations/listcustomerpayments.ts
 var ListCustomerPaymentsRequest$inboundSchema, ListCustomerPaymentsRequest$outboundSchema, ListCustomerPaymentsRequest$, ListCustomerPaymentsEmbedded$inboundSchema, ListCustomerPaymentsEmbedded$outboundSchema, ListCustomerPaymentsEmbedded$, ListCustomerPaymentsResponse$inboundSchema, ListCustomerPaymentsResponse$outboundSchema, ListCustomerPaymentsResponse$;
 var init_listcustomerpayments = __esm(() => {
@@ -47833,15 +48249,15 @@ var init_updatepaymentlink = __esm(() => {
 });
 
 // src/models/operations/updateprofile.ts
-var Mode15, Mode$inboundSchema2, Mode$outboundSchema2, Mode$2, UpdateProfileRequestBody$inboundSchema, UpdateProfileRequestBody$outboundSchema, UpdateProfileRequestBody$, UpdateProfileRequest$inboundSchema, UpdateProfileRequest$outboundSchema, UpdateProfileRequest$;
+var Mode16, Mode$inboundSchema2, Mode$outboundSchema2, Mode$2, UpdateProfileRequestBody$inboundSchema, UpdateProfileRequestBody$outboundSchema, UpdateProfileRequestBody$, UpdateProfileRequest$inboundSchema, UpdateProfileRequest$outboundSchema, UpdateProfileRequest$;
 var init_updateprofile = __esm(() => {
   init_esm();
   init_primitives();
-  Mode15 = {
+  Mode16 = {
     Live: "live",
     Test: "test"
   };
-  Mode$inboundSchema2 = nativeEnumType(Mode15);
+  Mode$inboundSchema2 = nativeEnumType(Mode16);
   Mode$outboundSchema2 = Mode$inboundSchema2;
   ((Mode$) => {
     Mode$.inboundSchema = Mode$inboundSchema2;
@@ -48052,6 +48468,7 @@ var init_operations = __esm(() => {
   init_cancelsubscription();
   init_createcapture();
   init_createclientlink();
+  init_createconnectbalancetransfer();
   init_createcustomer();
   init_createcustomerpayment();
   init_createmandate();
@@ -48072,6 +48489,7 @@ var init_operations = __esm(() => {
   init_getcapture();
   init_getchargeback();
   init_getclient();
+  init_getconnectbalancetransfer();
   init_getcurrentorganization();
   init_getcurrentprofile();
   init_getcustomer();
@@ -48106,6 +48524,7 @@ var init_operations = __esm(() => {
   init_listcaptures();
   init_listchargebacks();
   init_listclients();
+  init_listconnectbalancetransfers();
   init_listcustomerpayments();
   init_listcustomers();
   init_listinvoices();
@@ -48817,19 +49236,22 @@ The results are paginated.`,
   };
 });
 
-// src/funcs/capabilitiesList.ts
-function capabilitiesList(client, request, options) {
+// src/funcs/balanceTransfersCreate.ts
+function balanceTransfersCreate(client, request, options) {
   return new APIPromise($do6(client, request, options));
 }
 async function $do6(client, request, options) {
-  const parsed = safeParse(request, (value) => ListCapabilitiesRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => CreateConnectBalanceTransferRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
-  const path = pathToFunc("/capabilities")();
+  const body = encodeJSON("body", payload?.["entity-balance-transfer"], {
+    explode: true
+  });
+  const path = pathToFunc("/connect/balance-transfers")();
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/hal+json",
     "idempotency-key": encodeSimple("idempotency-key", payload?.["idempotency-key"], { explode: false, charEncoding: "none" })
   }));
@@ -48838,7 +49260,7 @@ async function $do6(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "list-capabilities",
+    operationID: "create-connect-balance-transfer",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -48856,7 +49278,7 @@ async function $do6(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -48870,7 +49292,7 @@ async function $do6(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["4XX", "5XX"],
+    errorCodes: ["422", "4XX", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -48878,54 +49300,52 @@ async function $do6(client, request, options) {
     return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
-  const [result] = await match(json(200, ListCapabilitiesResponse$inboundSchema, {
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, EntityBalanceTransferResponse$inboundSchema, {
     ctype: "application/hal+json"
-  }), fail("4XX"), fail("5XX"))(response, req);
+  }), jsonErr(422, ErrorResponse$inboundSchema, {
+    ctype: "application/hal+json"
+  }), 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_capabilitiesList = __esm(() => {
+var init_balanceTransfersCreate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
+  init_errors2();
+  init_models();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/capabilitiesList.ts
-var args6, tool$capabilitiesList;
-var init_capabilitiesList2 = __esm(() => {
-  init_capabilitiesList();
+// src/mcp-server/tools/balanceTransfersCreate.ts
+var args6, tool$balanceTransfersCreate;
+var init_balanceTransfersCreate2 = __esm(() => {
+  init_balanceTransfersCreate();
   init_operations();
   init_tools();
   args6 = {
-    request: ListCapabilitiesRequest$inboundSchema.optional()
+    request: CreateConnectBalanceTransferRequest$inboundSchema.optional()
   };
-  tool$capabilitiesList = {
-    name: "capabilities-list",
-    description: `List capabilities
-
-> \uD83D\uDEA7 Beta feature
->
-> This feature is currently in beta testing, and the final specification may still change.
-
-Retrieve a list of capabilities for an organization.
+  tool$balanceTransfersCreate = {
+    name: "balance-transfers-create",
+    description: `Create a Connect balance transfer
 
-This API provides detailed insights into the specific requirements and status of each client's onboarding journey.
-
-Capabilities are at the organization level, indicating if the organization can perform a given capability.
-
-For payments, regardless them being at the profile level, the capability is listed at the organization level.
-This means that if at least one of the clients's profiles can receive payments,
-the payments capability is enabled, communicating that the organization can indeed receive payments.`,
+This API endpoint allows you to create a balance transfer from your organization's balance to a connected organization's balance, or vice versa.
+You can also create a balance transfer between two connected organizations.
+To create a balance transfer, you must be authenticated as the source organization, and the destination organization must be a connected organization
+that has authorized the \`balance-transfers.write\` scope for your organization.`,
     args: args6,
     tool: async (client, args7, ctx) => {
-      const [result, apiCall] = await capabilitiesList(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await balanceTransfersCreate(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -48938,26 +49358,28 @@ the payments capability is enabled, communicating that the organization can inde
   };
 });
 
-// src/funcs/capturesCreate.ts
-function capturesCreate(client, request, options) {
+// src/funcs/balanceTransfersGet.ts
+function balanceTransfersGet(client, request, options) {
   return new APIPromise($do7(client, request, options));
 }
 async function $do7(client, request, options) {
-  const parsed = safeParse(request, (value) => CreateCaptureRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(request, (value) => GetConnectBalanceTransferRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload["entity-capture"], { explode: true });
+  const body = null;
   const pathParams = {
-    paymentId: encodeSimple("paymentId", payload.paymentId, {
+    id: encodeSimple("id", payload.id, {
       explode: false,
       charEncoding: "percent"
     })
   };
-  const path = pathToFunc("/payments/{paymentId}/captures")(pathParams);
+  const path = pathToFunc("/connect/balance-transfers/{id}")(pathParams);
+  const query = encodeFormQuery({
+    testmode: payload.testmode
+  });
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/hal+json",
     "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { explode: false, charEncoding: "none" })
   }));
@@ -48966,7 +49388,7 @@ async function $do7(client, request, options) {
   const context = {
     options: client._options,
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create-capture",
+    operationID: "get-connect-balance-transfer",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.security,
@@ -48984,10 +49406,11 @@ async function $do7(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     userAgent: client._options.userAgent,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
@@ -48998,7 +49421,7 @@ async function $do7(client, request, options) {
   const req = requestRes.value;
   const doResult = await client._do(req, {
     context,
-    errorCodes: ["404", "422", "4XX", "5XX"],
+    errorCodes: ["404", "4XX", "5XX"],
     retryConfig: context.retryConfig,
     retryCodes: context.retryCodes
   });
@@ -49009,9 +49432,9 @@ async function $do7(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, CaptureResponse$inboundSchema, {
+  const [result] = await match(json(200, EntityBalanceTransferResponse$inboundSchema, {
     ctype: "application/hal+json"
-  }), jsonErr([404, 422], ErrorResponse$inboundSchema, {
+  }), jsonErr(404, ErrorResponse$inboundSchema, {
     ctype: "application/hal+json"
   }), fail("4XX"), fail("5XX"))(response, req, { extraFields: responseFields });
   if (!result.ok) {
@@ -49019,7 +49442,7 @@ async function $do7(client, request, options) {
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_capturesCreate = __esm(() => {
+var init_balanceTransfersGet = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -49032,13 +49455,379 @@ var init_capturesCreate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/capturesCreate.ts
-var args7, tool$capturesCreate;
-var init_capturesCreate2 = __esm(() => {
-  init_capturesCreate();
+// src/mcp-server/tools/balanceTransfersGet.ts
+var args7, tool$balanceTransfersGet;
+var init_balanceTransfersGet2 = __esm(() => {
+  init_balanceTransfersGet();
   init_operations();
   init_tools();
   args7 = {
+    request: GetConnectBalanceTransferRequest$inboundSchema
+  };
+  tool$balanceTransfersGet = {
+    name: "balance-transfers-get",
+    description: `Get a Connect balance transfer
+
+Retrieve a single Connect balance transfer object by its ID.`,
+    args: args7,
+    tool: async (client, args8, ctx) => {
+      const [result, apiCall] = await balanceTransfersGet(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/balanceTransfersList.ts
+function balanceTransfersList(client, request, options) {
+  return new APIPromise($do8(client, request, options));
+}
+async function $do8(client, request, options) {
+  const parsed = safeParse(request, (value) => ListConnectBalanceTransfersRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/connect/balance-transfers")();
+  const query = encodeFormQuery({
+    from: payload?.from,
+    limit: payload?.limit,
+    sort: payload?.sort,
+    testmode: payload?.testmode
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/hal+json",
+    "idempotency-key": encodeSimple("idempotency-key", payload?.["idempotency-key"], { 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: "list-connect-balance-transfers",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 60000,
+        exponent: 1.5,
+        maxElapsedTime: 3600000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5xx"]
+  };
+  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: ["400", "4XX", "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, ListConnectBalanceTransfersResponse$inboundSchema, {
+    ctype: "application/hal+json"
+  }), jsonErr(400, ErrorResponse$inboundSchema, {
+    ctype: "application/hal+json"
+  }), 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_balanceTransfersList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/balanceTransfersList.ts
+var args8, tool$balanceTransfersList;
+var init_balanceTransfersList2 = __esm(() => {
+  init_balanceTransfersList();
+  init_operations();
+  init_tools();
+  args8 = {
+    request: ListConnectBalanceTransfersRequest$inboundSchema.optional()
+  };
+  tool$balanceTransfersList = {
+    name: "balance-transfers-list",
+    description: `List all Connect balance transfers
+
+Returns a paginated list of balance transfers associated with your organization. These may be a balance transfer that was received or sent from your balance, or a balance transfer that you initiated on behalf of your clients. If no balance transfers are available, the resulting array will be empty. This request should never throw an error.`,
+    args: args8,
+    tool: async (client, args9, ctx) => {
+      const [result, apiCall] = await balanceTransfersList(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/capabilitiesList.ts
+function capabilitiesList(client, request, options) {
+  return new APIPromise($do9(client, request, options));
+}
+async function $do9(client, request, options) {
+  const parsed = safeParse(request, (value) => ListCapabilitiesRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/capabilities")();
+  const headers = new Headers(compactMap({
+    Accept: "application/hal+json",
+    "idempotency-key": encodeSimple("idempotency-key", payload?.["idempotency-key"], { 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: "list-capabilities",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 60000,
+        exponent: 1.5,
+        maxElapsedTime: 3600000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5xx"]
+  };
+  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: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, ListCapabilitiesResponse$inboundSchema, {
+    ctype: "application/hal+json"
+  }), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_capabilitiesList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/capabilitiesList.ts
+var args9, tool$capabilitiesList;
+var init_capabilitiesList2 = __esm(() => {
+  init_capabilitiesList();
+  init_operations();
+  init_tools();
+  args9 = {
+    request: ListCapabilitiesRequest$inboundSchema.optional()
+  };
+  tool$capabilitiesList = {
+    name: "capabilities-list",
+    description: `List capabilities
+
+> \uD83D\uDEA7 Beta feature
+>
+> This feature is currently in beta testing, and the final specification may still change.
+
+Retrieve a list of capabilities for an organization.
+
+This API provides detailed insights into the specific requirements and status of each client's onboarding journey.
+
+Capabilities are at the organization level, indicating if the organization can perform a given capability.
+
+For payments, regardless them being at the profile level, the capability is listed at the organization level.
+This means that if at least one of the clients's profiles can receive payments,
+the payments capability is enabled, communicating that the organization can indeed receive payments.`,
+    args: args9,
+    tool: async (client, args10, ctx) => {
+      const [result, apiCall] = await capabilitiesList(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/capturesCreate.ts
+function capturesCreate(client, request, options) {
+  return new APIPromise($do10(client, request, options));
+}
+async function $do10(client, request, options) {
+  const parsed = safeParse(request, (value) => CreateCaptureRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload["entity-capture"], { explode: true });
+  const pathParams = {
+    paymentId: encodeSimple("paymentId", payload.paymentId, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/payments/{paymentId}/captures")(pathParams);
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/hal+json",
+    "idempotency-key": encodeSimple("idempotency-key", payload["idempotency-key"], { 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: "create-capture",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.security,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 60000,
+        exponent: 1.5,
+        maxElapsedTime: 3600000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5xx"]
+  };
+  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: ["404", "422", "4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, CaptureResponse$inboundSchema, {
+    ctype: "application/hal+json"
+  }), jsonErr([404, 422], ErrorResponse$inboundSchema, {
+    ctype: "application/hal+json"
+  }), 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_capturesCreate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_errors2();
+  init_models();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/capturesCreate.ts
+var args10, tool$capturesCreate;
+var init_capturesCreate2 = __esm(() => {
+  init_capturesCreate();
+  init_operations();
+  init_tools();
+  args10 = {
     request: CreateCaptureRequest$inboundSchema
   };
   tool$capturesCreate = {
@@ -49053,9 +49842,9 @@ and capture the amount at a later point.
 By default, Mollie captures payments automatically. If however you
 configured your payment with \`captureMode: manual\`, you can capture the payment using this endpoint after
 having collected the customer's authorization.`,
-    args: args7,
-    tool: async (client, args8, ctx) => {
-      const [result, apiCall] = await capturesCreate(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args10,
+    tool: async (client, args11, ctx) => {
+      const [result, apiCall] = await capturesCreate(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -49070,9 +49859,9 @@ having collected the customer's authorization.`,
 
 // src/funcs/capturesGet.ts
 function capturesGet(client, request, options) {
-  return new APIPromise($do8(client, request, options));
+  return new APIPromise($do11(client, request, options));
 }
-async function $do8(client, request, options) {
+async function $do11(client, request, options) {
   const parsed = safeParse(request, (value) => GetCaptureRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -49171,12 +49960,12 @@ var init_capturesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/capturesGet.ts
-var args8, tool$capturesGet;
+var args11, tool$capturesGet;
 var init_capturesGet2 = __esm(() => {
   init_capturesGet();
   init_operations();
   init_tools();
-  args8 = {
+  args11 = {
     request: GetCaptureRequest$inboundSchema
   };
   tool$capturesGet = {
@@ -49185,9 +49974,9 @@ var init_capturesGet2 = __esm(() => {
 
 Retrieve a single payment capture by its ID and the ID of its parent
 payment.`,
-    args: args8,
-    tool: async (client, args9, ctx) => {
-      const [result, apiCall] = await capturesGet(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args11,
+    tool: async (client, args12, ctx) => {
+      const [result, apiCall] = await capturesGet(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -49202,9 +49991,9 @@ payment.`,
 
 // src/funcs/capturesList.ts
 function capturesList(client, request, options) {
-  return new APIPromise($do9(client, request, options));
+  return new APIPromise($do12(client, request, options));
 }
-async function $do9(client, request, options) {
+async function $do12(client, request, options) {
   const parsed = safeParse(request, (value) => ListCapturesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -49300,12 +50089,12 @@ var init_capturesList = __esm(() => {
 });
 
 // src/mcp-server/tools/capturesList.ts
-var args9, tool$capturesList;
+var args12, tool$capturesList;
 var init_capturesList2 = __esm(() => {
   init_capturesList();
   init_operations();
   init_tools();
-  args9 = {
+  args12 = {
     request: ListCapturesRequest$inboundSchema
   };
   tool$capturesList = {
@@ -49315,9 +50104,9 @@ var init_capturesList2 = __esm(() => {
 Retrieve a list of all captures created for a specific payment.
 
 The results are paginated.`,
-    args: args9,
-    tool: async (client, args10, ctx) => {
-      const [result, apiCall] = await capturesList(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args12,
+    tool: async (client, args13, ctx) => {
+      const [result, apiCall] = await capturesList(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -49332,9 +50121,9 @@ The results are paginated.`,
 
 // src/funcs/chargebacksAll.ts
 function chargebacksAll(client, request, options) {
-  return new APIPromise($do10(client, request, options));
+  return new APIPromise($do13(client, request, options));
 }
-async function $do10(client, request, options) {
+async function $do13(client, request, options) {
   const parsed = safeParse(request, (value) => ListAllChargebacksRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -49426,12 +50215,12 @@ var init_chargebacksAll = __esm(() => {
 });
 
 // src/mcp-server/tools/chargebacksAll.ts
-var args10, tool$chargebacksAll;
+var args13, tool$chargebacksAll;
 var init_chargebacksAll2 = __esm(() => {
   init_chargebacksAll();
   init_operations();
   init_tools();
-  args10 = {
+  args13 = {
     request: ListAllChargebacksRequest$inboundSchema.optional()
   };
   tool$chargebacksAll = {
@@ -49441,9 +50230,9 @@ var init_chargebacksAll2 = __esm(() => {
 Retrieve all chargebacks initiated for all your payments.
 
 The results are paginated.`,
-    args: args10,
-    tool: async (client, args11, ctx) => {
-      const [result, apiCall] = await chargebacksAll(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args13,
+    tool: async (client, args14, ctx) => {
+      const [result, apiCall] = await chargebacksAll(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -49458,9 +50247,9 @@ The results are paginated.`,
 
 // src/funcs/chargebacksGet.ts
 function chargebacksGet(client, request, options) {
-  return new APIPromise($do11(client, request, options));
+  return new APIPromise($do14(client, request, options));
 }
-async function $do11(client, request, options) {
+async function $do14(client, request, options) {
   const parsed = safeParse(request, (value) => GetChargebackRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -49559,12 +50348,12 @@ var init_chargebacksGet = __esm(() => {
 });
 
 // src/mcp-server/tools/chargebacksGet.ts
-var args11, tool$chargebacksGet;
+var args14, tool$chargebacksGet;
 var init_chargebacksGet2 = __esm(() => {
   init_chargebacksGet();
   init_operations();
   init_tools();
-  args11 = {
+  args14 = {
     request: GetChargebackRequest$inboundSchema
   };
   tool$chargebacksGet = {
@@ -49572,9 +50361,9 @@ var init_chargebacksGet2 = __esm(() => {
     description: `Get payment chargeback
 
 Retrieve a single payment chargeback by its ID and the ID of its parent payment.`,
-    args: args11,
-    tool: async (client, args12, ctx) => {
-      const [result, apiCall] = await chargebacksGet(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args14,
+    tool: async (client, args15, ctx) => {
+      const [result, apiCall] = await chargebacksGet(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -49589,9 +50378,9 @@ Retrieve a single payment chargeback by its ID and the ID of its parent payment.
 
 // src/funcs/chargebacksList.ts
 function chargebacksList(client, request, options) {
-  return new APIPromise($do12(client, request, options));
+  return new APIPromise($do15(client, request, options));
 }
-async function $do12(client, request, options) {
+async function $do15(client, request, options) {
   const parsed = safeParse(request, (value) => ListChargebacksRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -49687,12 +50476,12 @@ var init_chargebacksList = __esm(() => {
 });
 
 // src/mcp-server/tools/chargebacksList.ts
-var args12, tool$chargebacksList;
+var args15, tool$chargebacksList;
 var init_chargebacksList2 = __esm(() => {
   init_chargebacksList();
   init_operations();
   init_tools();
-  args12 = {
+  args15 = {
     request: ListChargebacksRequest$inboundSchema
   };
   tool$chargebacksList = {
@@ -49702,9 +50491,9 @@ var init_chargebacksList2 = __esm(() => {
 Retrieve the chargebacks initiated for a specific payment.
 
 The results are paginated.`,
-    args: args12,
-    tool: async (client, args13, ctx) => {
-      const [result, apiCall] = await chargebacksList(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args15,
+    tool: async (client, args16, ctx) => {
+      const [result, apiCall] = await chargebacksList(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -49719,9 +50508,9 @@ The results are paginated.`,
 
 // src/funcs/clientLinksCreate.ts
 function clientLinksCreate(client, request, options) {
-  return new APIPromise($do13(client, request, options));
+  return new APIPromise($do16(client, request, options));
 }
-async function $do13(client, request, options) {
+async function $do16(client, request, options) {
   const parsed = safeParse(request, (value) => CreateClientLinkRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -49808,12 +50597,12 @@ var init_clientLinksCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/clientLinksCreate.ts
-var args13, tool$clientLinksCreate;
+var args16, tool$clientLinksCreate;
 var init_clientLinksCreate2 = __esm(() => {
   init_clientLinksCreate();
   init_operations();
   init_tools();
-  args13 = {
+  args16 = {
     request: CreateClientLinkRequest$inboundSchema.optional()
   };
   tool$clientLinksCreate = {
@@ -49873,9 +50662,9 @@ to the URL.
 > \uD83D\uDEA7
 >
 > A client link must be used within 30 days of creation. After that period, it will expire and you will need to create a new client link.`,
-    args: args13,
-    tool: async (client, args14, ctx) => {
-      const [result, apiCall] = await clientLinksCreate(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args16,
+    tool: async (client, args17, ctx) => {
+      const [result, apiCall] = await clientLinksCreate(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -49890,9 +50679,9 @@ to the URL.
 
 // src/funcs/clientsGet.ts
 function clientsGet(client, request, options) {
-  return new APIPromise($do14(client, request, options));
+  return new APIPromise($do17(client, request, options));
 }
-async function $do14(client, request, options) {
+async function $do17(client, request, options) {
   const parsed = safeParse(request, (value) => GetClientRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -49985,12 +50774,12 @@ var init_clientsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/clientsGet.ts
-var args14, tool$clientsGet;
+var args17, tool$clientsGet;
 var init_clientsGet2 = __esm(() => {
   init_clientsGet();
   init_operations();
   init_tools();
-  args14 = {
+  args17 = {
     request: GetClientRequest$inboundSchema
   };
   tool$clientsGet = {
@@ -49998,9 +50787,9 @@ var init_clientsGet2 = __esm(() => {
     description: `Get client
 
 Retrieve a single client by its ID.`,
-    args: args14,
-    tool: async (client, args15, ctx) => {
-      const [result, apiCall] = await clientsGet(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args17,
+    tool: async (client, args18, ctx) => {
+      const [result, apiCall] = await clientsGet(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -50015,9 +50804,9 @@ Retrieve a single client by its ID.`,
 
 // src/funcs/clientsList.ts
 function clientsList(client, request, options) {
-  return new APIPromise($do15(client, request, options));
+  return new APIPromise($do18(client, request, options));
 }
-async function $do15(client, request, options) {
+async function $do18(client, request, options) {
   const parsed = safeParse(request, (value) => ListClientsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -50106,12 +50895,12 @@ var init_clientsList = __esm(() => {
 });
 
 // src/mcp-server/tools/clientsList.ts
-var args15, tool$clientsList;
+var args18, tool$clientsList;
 var init_clientsList2 = __esm(() => {
   init_clientsList();
   init_operations();
   init_tools();
-  args15 = {
+  args18 = {
     request: ListClientsRequest$inboundSchema.optional()
   };
   tool$clientsList = {
@@ -50120,10 +50909,10 @@ var init_clientsList2 = __esm(() => {
 
 Retrieve a list of all clients linked to your account.
 
-The results are paginated.`,
-    args: args15,
-    tool: async (client, args16, ctx) => {
-      const [result, apiCall] = await clientsList(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+The results are paginated.`,
+    args: args18,
+    tool: async (client, args19, ctx) => {
+      const [result, apiCall] = await clientsList(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -50138,9 +50927,9 @@ The results are paginated.`,
 
 // src/funcs/customersCreate.ts
 function customersCreate(client, request, options) {
-  return new APIPromise($do16(client, request, options));
+  return new APIPromise($do19(client, request, options));
 }
-async function $do16(client, request, options) {
+async function $do19(client, request, options) {
   const parsed = safeParse(request, (value) => CreateCustomerRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -50227,12 +51016,12 @@ var init_customersCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/customersCreate.ts
-var args16, tool$customersCreate;
+var args19, tool$customersCreate;
 var init_customersCreate2 = __esm(() => {
   init_customersCreate();
   init_operations();
   init_tools();
-  args16 = {
+  args19 = {
     request: CreateCustomerRequest$inboundSchema.optional()
   };
   tool$customersCreate = {
@@ -50243,9 +51032,9 @@ Creates a simple minimal representation of a customer. Payments, recurring manda
 to this customer object, which simplifies management of recurring payments.
 
 Once registered, customers will also appear in your Mollie dashboard.`,
-    args: args16,
-    tool: async (client, args17, ctx) => {
-      const [result, apiCall] = await customersCreate(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args19,
+    tool: async (client, args20, ctx) => {
+      const [result, apiCall] = await customersCreate(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -50260,9 +51049,9 @@ Once registered, customers will also appear in your Mollie dashboard.`,
 
 // src/funcs/customersCreatePayment.ts
 function customersCreatePayment(client, request, options) {
-  return new APIPromise($do17(client, request, options));
+  return new APIPromise($do20(client, request, options));
 }
-async function $do17(client, request, options) {
+async function $do20(client, request, options) {
   const parsed = safeParse(request, (value) => CreateCustomerPaymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -50357,12 +51146,12 @@ var init_customersCreatePayment = __esm(() => {
 });
 
 // src/mcp-server/tools/customersCreatePayment.ts
-var args17, tool$customersCreatePayment;
+var args20, tool$customersCreatePayment;
 var init_customersCreatePayment2 = __esm(() => {
   init_customersCreatePayment();
   init_operations();
   init_tools();
-  args17 = {
+  args20 = {
     request: CreateCustomerPaymentRequest$inboundSchema
   };
   tool$customersCreatePayment = {
@@ -50380,9 +51169,9 @@ Linking customers to payments enables you to:
 
 This endpoint is effectively an alias of the [Create payment endpoint](create-payment) with the \`customerId\`
 parameter predefined.`,
-    args: args17,
-    tool: async (client, args18, ctx) => {
-      const [result, apiCall] = await customersCreatePayment(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args20,
+    tool: async (client, args21, ctx) => {
+      const [result, apiCall] = await customersCreatePayment(client, args21.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -50397,9 +51186,9 @@ parameter predefined.`,
 
 // src/funcs/customersDelete.ts
 function customersDelete(client, request, options) {
-  return new APIPromise($do18(client, request, options));
+  return new APIPromise($do21(client, request, options));
 }
-async function $do18(client, request, options) {
+async function $do21(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteCustomerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -50488,12 +51277,12 @@ var init_customersDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/customersDelete.ts
-var args18, tool$customersDelete;
+var args21, tool$customersDelete;
 var init_customersDelete2 = __esm(() => {
   init_customersDelete();
   init_operations();
   init_tools();
-  args18 = {
+  args21 = {
     request: DeleteCustomerRequest$inboundSchema
   };
   tool$customersDelete = {
@@ -50501,9 +51290,9 @@ var init_customersDelete2 = __esm(() => {
     description: `Delete customer
 
 Delete a customer. All mandates and subscriptions created for this customer will be canceled as well.`,
-    args: args18,
-    tool: async (client, args19, ctx) => {
-      const [result, apiCall] = await customersDelete(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args21,
+    tool: async (client, args22, ctx) => {
+      const [result, apiCall] = await customersDelete(client, args22.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -50518,9 +51307,9 @@ Delete a customer. All mandates and subscriptions created for this customer will
 
 // src/funcs/customersGet.ts
 function customersGet(client, request, options) {
-  return new APIPromise($do19(client, request, options));
+  return new APIPromise($do22(client, request, options));
 }
-async function $do19(client, request, options) {
+async function $do22(client, request, options) {
   const parsed = safeParse(request, (value) => GetCustomerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -50614,12 +51403,12 @@ var init_customersGet = __esm(() => {
 });
 
 // src/mcp-server/tools/customersGet.ts
-var args19, tool$customersGet;
+var args22, tool$customersGet;
 var init_customersGet2 = __esm(() => {
   init_customersGet();
   init_operations();
   init_tools();
-  args19 = {
+  args22 = {
     request: GetCustomerRequest$inboundSchema
   };
   tool$customersGet = {
@@ -50627,9 +51416,9 @@ var init_customersGet2 = __esm(() => {
     description: `Get customer
 
 Retrieve a single customer by its ID.`,
-    args: args19,
-    tool: async (client, args20, ctx) => {
-      const [result, apiCall] = await customersGet(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args22,
+    tool: async (client, args23, ctx) => {
+      const [result, apiCall] = await customersGet(client, args23.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -50644,9 +51433,9 @@ Retrieve a single customer by its ID.`,
 
 // src/funcs/customersList.ts
 function customersList(client, request, options) {
-  return new APIPromise($do20(client, request, options));
+  return new APIPromise($do23(client, request, options));
 }
-async function $do20(client, request, options) {
+async function $do23(client, request, options) {
   const parsed = safeParse(request, (value) => ListCustomersRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -50736,12 +51525,12 @@ var init_customersList = __esm(() => {
 });
 
 // src/mcp-server/tools/customersList.ts
-var args20, tool$customersList;
+var args23, tool$customersList;
 var init_customersList2 = __esm(() => {
   init_customersList();
   init_operations();
   init_tools();
-  args20 = {
+  args23 = {
     request: ListCustomersRequest$inboundSchema.optional()
   };
   tool$customersList = {
@@ -50751,9 +51540,9 @@ var init_customersList2 = __esm(() => {
 Retrieve a list of all customers.
 
 The results are paginated.`,
-    args: args20,
-    tool: async (client, args21, ctx) => {
-      const [result, apiCall] = await customersList(client, args21.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args23,
+    tool: async (client, args24, ctx) => {
+      const [result, apiCall] = await customersList(client, args24.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -50768,9 +51557,9 @@ The results are paginated.`,
 
 // src/funcs/customersListPayments.ts
 function customersListPayments(client, request, options) {
-  return new APIPromise($do21(client, request, options));
+  return new APIPromise($do24(client, request, options));
 }
-async function $do21(client, request, options) {
+async function $do24(client, request, options) {
   const parsed = safeParse(request, (value) => ListCustomerPaymentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -50867,12 +51656,12 @@ var init_customersListPayments = __esm(() => {
 });
 
 // src/mcp-server/tools/customersListPayments.ts
-var args21, tool$customersListPayments;
+var args24, tool$customersListPayments;
 var init_customersListPayments2 = __esm(() => {
   init_customersListPayments();
   init_operations();
   init_tools();
-  args21 = {
+  args24 = {
     request: ListCustomerPaymentsRequest$inboundSchema
   };
   tool$customersListPayments = {
@@ -50880,9 +51669,9 @@ var init_customersListPayments2 = __esm(() => {
     description: `List customer payments
 
 Retrieve all payments linked to the customer.`,
-    args: args21,
-    tool: async (client, args22, ctx) => {
-      const [result, apiCall] = await customersListPayments(client, args22.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args24,
+    tool: async (client, args25, ctx) => {
+      const [result, apiCall] = await customersListPayments(client, args25.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -50897,9 +51686,9 @@ Retrieve all payments linked to the customer.`,
 
 // src/funcs/customersUpdate.ts
 function customersUpdate(client, request, options) {
-  return new APIPromise($do22(client, request, options));
+  return new APIPromise($do25(client, request, options));
 }
-async function $do22(client, request, options) {
+async function $do25(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateCustomerRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -50992,12 +51781,12 @@ var init_customersUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/customersUpdate.ts
-var args22, tool$customersUpdate;
+var args25, tool$customersUpdate;
 var init_customersUpdate2 = __esm(() => {
   init_customersUpdate();
   init_operations();
   init_tools();
-  args22 = {
+  args25 = {
     request: UpdateCustomerRequest$inboundSchema
   };
   tool$customersUpdate = {
@@ -51007,9 +51796,9 @@ var init_customersUpdate2 = __esm(() => {
 Update an existing customer.
 
 For an in-depth explanation of each parameter, refer to the [Create customer](create-customer) endpoint.`,
-    args: args22,
-    tool: async (client, args23, ctx) => {
-      const [result, apiCall] = await customersUpdate(client, args23.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args25,
+    tool: async (client, args26, ctx) => {
+      const [result, apiCall] = await customersUpdate(client, args26.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51024,9 +51813,9 @@ For an in-depth explanation of each parameter, refer to the [Create customer](cr
 
 // src/funcs/delayedRoutingCreate.ts
 function delayedRoutingCreate(client, request, options) {
-  return new APIPromise($do23(client, request, options));
+  return new APIPromise($do26(client, request, options));
 }
-async function $do23(client, request, options) {
+async function $do26(client, request, options) {
   const parsed = safeParse(request, (value) => PaymentCreateRouteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51119,12 +51908,12 @@ var init_delayedRoutingCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/delayedRoutingCreate.ts
-var args23, tool$delayedRoutingCreate;
+var args26, tool$delayedRoutingCreate;
 var init_delayedRoutingCreate2 = __esm(() => {
   init_delayedRoutingCreate();
   init_operations();
   init_tools();
-  args23 = {
+  args26 = {
     request: PaymentCreateRouteRequest$inboundSchema
   };
   tool$delayedRoutingCreate = {
@@ -51133,9 +51922,9 @@ var init_delayedRoutingCreate2 = __esm(() => {
 
 Create a route for a specific payment.
 The routed amount is credited to the account of your customer.`,
-    args: args23,
-    tool: async (client, args24, ctx) => {
-      const [result, apiCall] = await delayedRoutingCreate(client, args24.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args26,
+    tool: async (client, args27, ctx) => {
+      const [result, apiCall] = await delayedRoutingCreate(client, args27.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51150,9 +51939,9 @@ The routed amount is credited to the account of your customer.`,
 
 // src/funcs/delayedRoutingList.ts
 function delayedRoutingList(client, request, options) {
-  return new APIPromise($do24(client, request, options));
+  return new APIPromise($do27(client, request, options));
 }
-async function $do24(client, request, options) {
+async function $do27(client, request, options) {
   const parsed = safeParse(request, (value) => PaymentListRoutesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51245,12 +52034,12 @@ var init_delayedRoutingList = __esm(() => {
 });
 
 // src/mcp-server/tools/delayedRoutingList.ts
-var args24, tool$delayedRoutingList;
+var args27, tool$delayedRoutingList;
 var init_delayedRoutingList2 = __esm(() => {
   init_delayedRoutingList();
   init_operations();
   init_tools();
-  args24 = {
+  args27 = {
     request: PaymentListRoutesRequest$inboundSchema
   };
   tool$delayedRoutingList = {
@@ -51258,9 +52047,9 @@ var init_delayedRoutingList2 = __esm(() => {
     description: `List payment routes
 
 Retrieve a list of all routes created for a specific payment.`,
-    args: args24,
-    tool: async (client, args25, ctx) => {
-      const [result, apiCall] = await delayedRoutingList(client, args25.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args27,
+    tool: async (client, args28, ctx) => {
+      const [result, apiCall] = await delayedRoutingList(client, args28.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51275,9 +52064,9 @@ Retrieve a list of all routes created for a specific payment.`,
 
 // src/funcs/invoicesGet.ts
 function invoicesGet(client, request, options) {
-  return new APIPromise($do25(client, request, options));
+  return new APIPromise($do28(client, request, options));
 }
-async function $do25(client, request, options) {
+async function $do28(client, request, options) {
   const parsed = safeParse(request, (value) => GetInvoiceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51367,12 +52156,12 @@ var init_invoicesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/invoicesGet.ts
-var args25, tool$invoicesGet;
+var args28, tool$invoicesGet;
 var init_invoicesGet2 = __esm(() => {
   init_invoicesGet();
   init_operations();
   init_tools();
-  args25 = {
+  args28 = {
     request: GetInvoiceRequest$inboundSchema
   };
   tool$invoicesGet = {
@@ -51383,9 +52172,9 @@ Retrieve a single invoice by its ID.
 
 If you want to retrieve the details of an invoice by its invoice number,
 call the [List invoices](list-invoices) endpoint with the \`reference\` parameter.`,
-    args: args25,
-    tool: async (client, args26, ctx) => {
-      const [result, apiCall] = await invoicesGet(client, args26.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args28,
+    tool: async (client, args29, ctx) => {
+      const [result, apiCall] = await invoicesGet(client, args29.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51400,9 +52189,9 @@ call the [List invoices](list-invoices) endpoint with the \`reference\` paramete
 
 // src/funcs/invoicesList.ts
 function invoicesList(client, request, options) {
-  return new APIPromise($do26(client, request, options));
+  return new APIPromise($do29(client, request, options));
 }
-async function $do26(client, request, options) {
+async function $do29(client, request, options) {
   const parsed = safeParse(request, (value) => ListInvoicesRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51494,12 +52283,12 @@ var init_invoicesList = __esm(() => {
 });
 
 // src/mcp-server/tools/invoicesList.ts
-var args26, tool$invoicesList;
+var args29, tool$invoicesList;
 var init_invoicesList2 = __esm(() => {
   init_invoicesList();
   init_operations();
   init_tools();
-  args26 = {
+  args29 = {
     request: ListInvoicesRequest$inboundSchema.optional()
   };
   tool$invoicesList = {
@@ -51510,9 +52299,9 @@ Retrieve a list of all your invoices, optionally filtered by year or by
 invoice reference.
 
 The results are paginated.`,
-    args: args26,
-    tool: async (client, args27, ctx) => {
-      const [result, apiCall] = await invoicesList(client, args27.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args29,
+    tool: async (client, args30, ctx) => {
+      const [result, apiCall] = await invoicesList(client, args30.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51527,9 +52316,9 @@ The results are paginated.`,
 
 // src/funcs/mandatesCreate.ts
 function mandatesCreate(client, request, options) {
-  return new APIPromise($do27(client, request, options));
+  return new APIPromise($do30(client, request, options));
 }
-async function $do27(client, request, options) {
+async function $do30(client, request, options) {
   const parsed = safeParse(request, (value) => CreateMandateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51620,12 +52409,12 @@ var init_mandatesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/mandatesCreate.ts
-var args27, tool$mandatesCreate;
+var args30, tool$mandatesCreate;
 var init_mandatesCreate2 = __esm(() => {
   init_mandatesCreate();
   init_operations();
   init_tools();
-  args27 = {
+  args30 = {
     request: CreateMandateRequest$inboundSchema
   };
   tool$mandatesCreate = {
@@ -51637,9 +52426,9 @@ account recurrently.
 
 It is only possible to create mandates for IBANs and PayPal billing agreements with this endpoint. To create
 mandates for cards, your customers need to perform a 'first payment' with their card.`,
-    args: args27,
-    tool: async (client, args28, ctx) => {
-      const [result, apiCall] = await mandatesCreate(client, args28.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args30,
+    tool: async (client, args31, ctx) => {
+      const [result, apiCall] = await mandatesCreate(client, args31.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51654,9 +52443,9 @@ mandates for cards, your customers need to perform a 'first payment' with their
 
 // src/funcs/mandatesGet.ts
 function mandatesGet(client, request, options) {
-  return new APIPromise($do28(client, request, options));
+  return new APIPromise($do31(client, request, options));
 }
-async function $do28(client, request, options) {
+async function $do31(client, request, options) {
   const parsed = safeParse(request, (value) => GetMandateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51754,12 +52543,12 @@ var init_mandatesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/mandatesGet.ts
-var args28, tool$mandatesGet;
+var args31, tool$mandatesGet;
 var init_mandatesGet2 = __esm(() => {
   init_mandatesGet();
   init_operations();
   init_tools();
-  args28 = {
+  args31 = {
     request: GetMandateRequest$inboundSchema
   };
   tool$mandatesGet = {
@@ -51768,9 +52557,9 @@ var init_mandatesGet2 = __esm(() => {
 
 Retrieve a single mandate by its ID. Depending on the type of mandate, the object will contain the customer's bank
 account details, card details, or PayPal account details.`,
-    args: args28,
-    tool: async (client, args29, ctx) => {
-      const [result, apiCall] = await mandatesGet(client, args29.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args31,
+    tool: async (client, args32, ctx) => {
+      const [result, apiCall] = await mandatesGet(client, args32.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51785,9 +52574,9 @@ account details, card details, or PayPal account details.`,
 
 // src/funcs/mandatesList.ts
 function mandatesList(client, request, options) {
-  return new APIPromise($do29(client, request, options));
+  return new APIPromise($do32(client, request, options));
 }
-async function $do29(client, request, options) {
+async function $do32(client, request, options) {
   const parsed = safeParse(request, (value) => ListMandatesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -51883,12 +52672,12 @@ var init_mandatesList = __esm(() => {
 });
 
 // src/mcp-server/tools/mandatesList.ts
-var args29, tool$mandatesList;
+var args32, tool$mandatesList;
 var init_mandatesList2 = __esm(() => {
   init_mandatesList();
   init_operations();
   init_tools();
-  args29 = {
+  args32 = {
     request: ListMandatesRequest$inboundSchema
   };
   tool$mandatesList = {
@@ -51898,9 +52687,9 @@ var init_mandatesList2 = __esm(() => {
 Retrieve a list of all mandates.
 
 The results are paginated.`,
-    args: args29,
-    tool: async (client, args30, ctx) => {
-      const [result, apiCall] = await mandatesList(client, args30.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args32,
+    tool: async (client, args33, ctx) => {
+      const [result, apiCall] = await mandatesList(client, args33.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -51915,9 +52704,9 @@ The results are paginated.`,
 
 // src/funcs/mandatesRevoke.ts
 function mandatesRevoke(client, request, options) {
-  return new APIPromise($do30(client, request, options));
+  return new APIPromise($do33(client, request, options));
 }
-async function $do30(client, request, options) {
+async function $do33(client, request, options) {
   const parsed = safeParse(request, (value) => RevokeMandateRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52010,12 +52799,12 @@ var init_mandatesRevoke = __esm(() => {
 });
 
 // src/mcp-server/tools/mandatesRevoke.ts
-var args30, tool$mandatesRevoke;
+var args33, tool$mandatesRevoke;
 var init_mandatesRevoke2 = __esm(() => {
   init_mandatesRevoke();
   init_operations();
   init_tools();
-  args30 = {
+  args33 = {
     request: RevokeMandateRequest$inboundSchema
   };
   tool$mandatesRevoke = {
@@ -52024,9 +52813,9 @@ var init_mandatesRevoke2 = __esm(() => {
 
 Revoke a customer's mandate. You will no longer be able to charge the customer's bank account or card with this
 mandate, and all connected subscriptions will be canceled.`,
-    args: args30,
-    tool: async (client, args31, ctx) => {
-      const [result, apiCall] = await mandatesRevoke(client, args31.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args33,
+    tool: async (client, args34, ctx) => {
+      const [result, apiCall] = await mandatesRevoke(client, args34.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52041,9 +52830,9 @@ mandate, and all connected subscriptions will be canceled.`,
 
 // src/funcs/methodsAll.ts
 function methodsAll(client, request, options) {
-  return new APIPromise($do31(client, request, options));
+  return new APIPromise($do34(client, request, options));
 }
-async function $do31(client, request, options) {
+async function $do34(client, request, options) {
   const parsed = safeParse(request, (value) => ListAllMethodsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52136,12 +52925,12 @@ var init_methodsAll = __esm(() => {
 });
 
 // src/mcp-server/tools/methodsAll.ts
-var args31, tool$methodsAll;
+var args34, tool$methodsAll;
 var init_methodsAll2 = __esm(() => {
   init_methodsAll();
   init_operations();
   init_tools();
-  args31 = {
+  args34 = {
     request: ListAllMethodsRequest$inboundSchema.optional()
   };
   tool$methodsAll = {
@@ -52152,9 +52941,9 @@ Retrieve all payment methods that Mollie offers, regardless of the eligibility o
 method. The results of this endpoint are **not** paginated — unlike most other list endpoints in our API.
 
 The list can optionally be filtered using a number of parameters described below.`,
-    args: args31,
-    tool: async (client, args32, ctx) => {
-      const [result, apiCall] = await methodsAll(client, args32.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args34,
+    tool: async (client, args35, ctx) => {
+      const [result, apiCall] = await methodsAll(client, args35.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52169,9 +52958,9 @@ The list can optionally be filtered using a number of parameters described below
 
 // src/funcs/methodsGet.ts
 function methodsGet(client, request, options) {
-  return new APIPromise($do32(client, request, options));
+  return new APIPromise($do35(client, request, options));
 }
-async function $do32(client, request, options) {
+async function $do35(client, request, options) {
   const parsed = safeParse(request, (value) => GetMethodRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52270,12 +53059,12 @@ var init_methodsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/methodsGet.ts
-var args32, tool$methodsGet;
+var args35, tool$methodsGet;
 var init_methodsGet2 = __esm(() => {
   init_methodsGet();
   init_operations();
   init_tools();
-  args32 = {
+  args35 = {
     request: GetMethodRequest$inboundSchema
   };
   tool$methodsGet = {
@@ -52294,9 +53083,9 @@ endpoint](list-methods) to retrieve all payment methods that are available.
 
 Additionally, it is possible to check if wallet methods such as Apple Pay
 are enabled by passing the wallet ID (\`applepay\`) as the method ID.`,
-    args: args32,
-    tool: async (client, args33, ctx) => {
-      const [result, apiCall] = await methodsGet(client, args33.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args35,
+    tool: async (client, args36, ctx) => {
+      const [result, apiCall] = await methodsGet(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52311,9 +53100,9 @@ are enabled by passing the wallet ID (\`applepay\`) as the method ID.`,
 
 // src/funcs/methodsList.ts
 function methodsList(client, request, options) {
-  return new APIPromise($do33(client, request, options));
+  return new APIPromise($do36(client, request, options));
 }
-async function $do33(client, request, options) {
+async function $do36(client, request, options) {
   const parsed = safeParse(request, (value) => ListMethodsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52410,12 +53199,12 @@ var init_methodsList = __esm(() => {
 });
 
 // src/mcp-server/tools/methodsList.ts
-var args33, tool$methodsList;
+var args36, tool$methodsList;
 var init_methodsList2 = __esm(() => {
   init_methodsList();
   init_operations();
   init_tools();
-  args33 = {
+  args36 = {
     request: ListMethodsRequest$inboundSchema.optional()
   };
   tool$methodsList = {
@@ -52438,9 +53227,9 @@ below.
 By default, only payment methods for the Euro currency are returned. If you
 wish to retrieve payment methods which exclusively support other currencies (e.g. Twint), you need to use the
 \`amount\` parameters.`,
-    args: args33,
-    tool: async (client, args34, ctx) => {
-      const [result, apiCall] = await methodsList(client, args34.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args36,
+    tool: async (client, args37, ctx) => {
+      const [result, apiCall] = await methodsList(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52455,9 +53244,9 @@ wish to retrieve payment methods which exclusively support other currencies (e.g
 
 // src/funcs/onboardingGet.ts
 function onboardingGet(client, request, options) {
-  return new APIPromise($do34(client, request, options));
+  return new APIPromise($do37(client, request, options));
 }
-async function $do34(client, request, options) {
+async function $do37(client, request, options) {
   const parsed = safeParse(request, (value) => GetOnboardingStatusRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52535,12 +53324,12 @@ var init_onboardingGet = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingGet.ts
-var args34, tool$onboardingGet;
+var args37, tool$onboardingGet;
 var init_onboardingGet2 = __esm(() => {
   init_onboardingGet();
   init_operations();
   init_tools();
-  args34 = {
+  args37 = {
     request: GetOnboardingStatusRequest$inboundSchema.optional()
   };
   tool$onboardingGet = {
@@ -52548,9 +53337,9 @@ var init_onboardingGet2 = __esm(() => {
     description: `Get onboarding status
 
 Retrieve the onboarding status of the currently authenticated organization.`,
-    args: args34,
-    tool: async (client, args35, ctx) => {
-      const [result, apiCall] = await onboardingGet(client, args35.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args37,
+    tool: async (client, args38, ctx) => {
+      const [result, apiCall] = await onboardingGet(client, args38.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52565,9 +53354,9 @@ Retrieve the onboarding status of the currently authenticated organization.`,
 
 // src/funcs/onboardingSubmit.ts
 function onboardingSubmit(client, request, options) {
-  return new APIPromise($do35(client, request, options));
+  return new APIPromise($do38(client, request, options));
 }
-async function $do35(client, request, options) {
+async function $do38(client, request, options) {
   const parsed = safeParse(request, (value) => SubmitOnboardingDataRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52644,12 +53433,12 @@ var init_onboardingSubmit = __esm(() => {
 });
 
 // src/mcp-server/tools/onboardingSubmit.ts
-var args35, tool$onboardingSubmit;
+var args38, tool$onboardingSubmit;
 var init_onboardingSubmit2 = __esm(() => {
   init_onboardingSubmit();
   init_operations();
   init_tools();
-  args35 = {
+  args38 = {
     request: SubmitOnboardingDataRequest$inboundSchema.optional()
   };
   tool$onboardingSubmit = {
@@ -52662,9 +53451,9 @@ onboarding process for your merchants.**
 Submit data that will be prefilled in the merchant's onboarding. The data you submit will only be processed when the
 onboarding status is \`needs-data\`.  
 Information that the merchant has entered in their dashboard will not be overwritten.`,
-    args: args35,
-    tool: async (client, args36, ctx) => {
-      const [result, apiCall] = await onboardingSubmit(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args38,
+    tool: async (client, args39, ctx) => {
+      const [result, apiCall] = await onboardingSubmit(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52679,9 +53468,9 @@ Information that the merchant has entered in their dashboard will not be overwri
 
 // src/funcs/organizationsGet.ts
 function organizationsGet(client, request, options) {
-  return new APIPromise($do36(client, request, options));
+  return new APIPromise($do39(client, request, options));
 }
-async function $do36(client, request, options) {
+async function $do39(client, request, options) {
   const parsed = safeParse(request, (value) => GetOrganizationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52775,12 +53564,12 @@ var init_organizationsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/organizationsGet.ts
-var args36, tool$organizationsGet;
+var args39, tool$organizationsGet;
 var init_organizationsGet2 = __esm(() => {
   init_organizationsGet();
   init_operations();
   init_tools();
-  args36 = {
+  args39 = {
     request: GetOrganizationRequest$inboundSchema
   };
   tool$organizationsGet = {
@@ -52793,9 +53582,9 @@ You can normally only retrieve the currently authenticated organization with thi
 for OAuth apps. See also [Get current organization](get-current-organization).
 
 If you have a *partner account*', you can retrieve organization details of connected organizations.`,
-    args: args36,
-    tool: async (client, args37, ctx) => {
-      const [result, apiCall] = await organizationsGet(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args39,
+    tool: async (client, args40, ctx) => {
+      const [result, apiCall] = await organizationsGet(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52810,9 +53599,9 @@ If you have a *partner account*', you can retrieve organization details of conne
 
 // src/funcs/organizationsGetCurrent.ts
 function organizationsGetCurrent(client, request, options) {
-  return new APIPromise($do37(client, request, options));
+  return new APIPromise($do40(client, request, options));
 }
-async function $do37(client, request, options) {
+async function $do40(client, request, options) {
   const parsed = safeParse(request, (value) => GetCurrentOrganizationRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -52890,12 +53679,12 @@ var init_organizationsGetCurrent = __esm(() => {
 });
 
 // src/mcp-server/tools/organizationsGetCurrent.ts
-var args37, tool$organizationsGetCurrent;
+var args40, tool$organizationsGetCurrent;
 var init_organizationsGetCurrent2 = __esm(() => {
   init_organizationsGetCurrent();
   init_operations();
   init_tools();
-  args37 = {
+  args40 = {
     request: GetCurrentOrganizationRequest$inboundSchema.optional()
   };
   tool$organizationsGetCurrent = {
@@ -52907,9 +53696,9 @@ endpoint.
 
 For a complete reference of the organization object, refer to the [Get organization](get-organization) endpoint
 documentation.`,
-    args: args37,
-    tool: async (client, args38, ctx) => {
-      const [result, apiCall] = await organizationsGetCurrent(client, args38.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args40,
+    tool: async (client, args41, ctx) => {
+      const [result, apiCall] = await organizationsGetCurrent(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52924,9 +53713,9 @@ documentation.`,
 
 // src/funcs/organizationsGetPartner.ts
 function organizationsGetPartner(client, request, options) {
-  return new APIPromise($do38(client, request, options));
+  return new APIPromise($do41(client, request, options));
 }
-async function $do38(client, request, options) {
+async function $do41(client, request, options) {
   const parsed = safeParse(request, (value) => GetPartnerStatusRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53003,12 +53792,12 @@ var init_organizationsGetPartner = __esm(() => {
 });
 
 // src/mcp-server/tools/organizationsGetPartner.ts
-var args38, tool$organizationsGetPartner;
+var args41, tool$organizationsGetPartner;
 var init_organizationsGetPartner2 = __esm(() => {
   init_organizationsGetPartner();
   init_operations();
   init_tools();
-  args38 = {
+  args41 = {
     request: GetPartnerStatusRequest$inboundSchema.optional()
   };
   tool$organizationsGetPartner = {
@@ -53017,9 +53806,9 @@ var init_organizationsGetPartner2 = __esm(() => {
 
 Retrieve partnership details about the currently authenticated organization. Only relevant for so-called *partner
 accounts*.`,
-    args: args38,
-    tool: async (client, args39, ctx) => {
-      const [result, apiCall] = await organizationsGetPartner(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args41,
+    tool: async (client, args42, ctx) => {
+      const [result, apiCall] = await organizationsGetPartner(client, args42.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53034,9 +53823,9 @@ accounts*.`,
 
 // src/funcs/paymentLinksCreate.ts
 function paymentLinksCreate(client, request, options) {
-  return new APIPromise($do39(client, request, options));
+  return new APIPromise($do42(client, request, options));
 }
-async function $do39(client, request, options) {
+async function $do42(client, request, options) {
   const parsed = safeParse(request, (value) => CreatePaymentLinkRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53121,12 +53910,12 @@ var init_paymentLinksCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksCreate.ts
-var args39, tool$paymentLinksCreate;
+var args42, tool$paymentLinksCreate;
 var init_paymentLinksCreate2 = __esm(() => {
   init_paymentLinksCreate();
   init_operations();
   init_tools();
-  args39 = {
+  args42 = {
     request: CreatePaymentLinkRequest$inboundSchema.optional()
   };
   tool$paymentLinksCreate = {
@@ -53136,9 +53925,9 @@ var init_paymentLinksCreate2 = __esm(() => {
 With the Payment links API you can generate payment links that by default, unlike regular payments, do not expire.
 The payment link can be shared with your customers and will redirect them to them the payment page where they can
 complete the payment. A [payment](get-payment) will only be created once the customer initiates the payment.`,
-    args: args39,
-    tool: async (client, args40, ctx) => {
-      const [result, apiCall] = await paymentLinksCreate(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args42,
+    tool: async (client, args43, ctx) => {
+      const [result, apiCall] = await paymentLinksCreate(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53153,9 +53942,9 @@ complete the payment. A [payment](get-payment) will only be created once the cus
 
 // src/funcs/paymentLinksDelete.ts
 function paymentLinksDelete(client, request, options) {
-  return new APIPromise($do40(client, request, options));
+  return new APIPromise($do43(client, request, options));
 }
-async function $do40(client, request, options) {
+async function $do43(client, request, options) {
   const parsed = safeParse(request, (value) => DeletePaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53244,12 +54033,12 @@ var init_paymentLinksDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksDelete.ts
-var args40, tool$paymentLinksDelete;
+var args43, tool$paymentLinksDelete;
 var init_paymentLinksDelete2 = __esm(() => {
   init_paymentLinksDelete();
   init_operations();
   init_tools();
-  args40 = {
+  args43 = {
     request: DeletePaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksDelete = {
@@ -53263,9 +54052,9 @@ Once deleted, the payment link will no longer show up in the API or Mollie dashb
 
 To simply disable a payment link without fully deleting it, you can use the \`archived\` parameter on the
 [Update payment link](update-payment-link) endpoint instead.`,
-    args: args40,
-    tool: async (client, args41, ctx) => {
-      const [result, apiCall] = await paymentLinksDelete(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args43,
+    tool: async (client, args44, ctx) => {
+      const [result, apiCall] = await paymentLinksDelete(client, args44.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53280,9 +54069,9 @@ To simply disable a payment link without fully deleting it, you can use the \`ar
 
 // src/funcs/paymentLinksGet.ts
 function paymentLinksGet(client, request, options) {
-  return new APIPromise($do41(client, request, options));
+  return new APIPromise($do44(client, request, options));
 }
-async function $do41(client, request, options) {
+async function $do44(client, request, options) {
   const parsed = safeParse(request, (value) => GetPaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53376,12 +54165,12 @@ var init_paymentLinksGet = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksGet.ts
-var args41, tool$paymentLinksGet;
+var args44, tool$paymentLinksGet;
 var init_paymentLinksGet2 = __esm(() => {
   init_paymentLinksGet();
   init_operations();
   init_tools();
-  args41 = {
+  args44 = {
     request: GetPaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksGet = {
@@ -53389,9 +54178,9 @@ var init_paymentLinksGet2 = __esm(() => {
     description: `Get payment link
 
 Retrieve a single payment link by its ID.`,
-    args: args41,
-    tool: async (client, args42, ctx) => {
-      const [result, apiCall] = await paymentLinksGet(client, args42.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args44,
+    tool: async (client, args45, ctx) => {
+      const [result, apiCall] = await paymentLinksGet(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53406,9 +54195,9 @@ Retrieve a single payment link by its ID.`,
 
 // src/funcs/paymentLinksList.ts
 function paymentLinksList(client, request, options) {
-  return new APIPromise($do42(client, request, options));
+  return new APIPromise($do45(client, request, options));
 }
-async function $do42(client, request, options) {
+async function $do45(client, request, options) {
   const parsed = safeParse(request, (value) => ListPaymentLinksRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53497,12 +54286,12 @@ var init_paymentLinksList = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksList.ts
-var args42, tool$paymentLinksList;
+var args45, tool$paymentLinksList;
 var init_paymentLinksList2 = __esm(() => {
   init_paymentLinksList();
   init_operations();
   init_tools();
-  args42 = {
+  args45 = {
     request: ListPaymentLinksRequest$inboundSchema.optional()
   };
   tool$paymentLinksList = {
@@ -53512,9 +54301,9 @@ var init_paymentLinksList2 = __esm(() => {
 Retrieve a list of all payment links.
 
 The results are paginated.`,
-    args: args42,
-    tool: async (client, args43, ctx) => {
-      const [result, apiCall] = await paymentLinksList(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args45,
+    tool: async (client, args46, ctx) => {
+      const [result, apiCall] = await paymentLinksList(client, args46.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53529,9 +54318,9 @@ The results are paginated.`,
 
 // src/funcs/paymentLinksListPayments.ts
 function paymentLinksListPayments(client, request, options) {
-  return new APIPromise($do43(client, request, options));
+  return new APIPromise($do46(client, request, options));
 }
-async function $do43(client, request, options) {
+async function $do46(client, request, options) {
   const parsed = safeParse(request, (value) => GetPaymentLinkPaymentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53627,12 +54416,12 @@ var init_paymentLinksListPayments = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksListPayments.ts
-var args43, tool$paymentLinksListPayments;
+var args46, tool$paymentLinksListPayments;
 var init_paymentLinksListPayments2 = __esm(() => {
   init_paymentLinksListPayments();
   init_operations();
   init_tools();
-  args43 = {
+  args46 = {
     request: GetPaymentLinkPaymentsRequest$inboundSchema
   };
   tool$paymentLinksListPayments = {
@@ -53642,9 +54431,9 @@ var init_paymentLinksListPayments2 = __esm(() => {
 Retrieve the list of payments for a specific payment link.
 
 The results are paginated.`,
-    args: args43,
-    tool: async (client, args44, ctx) => {
-      const [result, apiCall] = await paymentLinksListPayments(client, args44.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args46,
+    tool: async (client, args47, ctx) => {
+      const [result, apiCall] = await paymentLinksListPayments(client, args47.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53659,9 +54448,9 @@ The results are paginated.`,
 
 // src/funcs/paymentLinksUpdate.ts
 function paymentLinksUpdate(client, request, options) {
-  return new APIPromise($do44(client, request, options));
+  return new APIPromise($do47(client, request, options));
 }
-async function $do44(client, request, options) {
+async function $do47(client, request, options) {
   const parsed = safeParse(request, (value) => UpdatePaymentLinkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53752,12 +54541,12 @@ var init_paymentLinksUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentLinksUpdate.ts
-var args44, tool$paymentLinksUpdate;
+var args47, tool$paymentLinksUpdate;
 var init_paymentLinksUpdate2 = __esm(() => {
   init_paymentLinksUpdate();
   init_operations();
   init_tools();
-  args44 = {
+  args47 = {
     request: UpdatePaymentLinkRequest$inboundSchema
   };
   tool$paymentLinksUpdate = {
@@ -53765,9 +54554,9 @@ var init_paymentLinksUpdate2 = __esm(() => {
     description: `Update payment link
 
 Certain details of an existing payment link can be updated.`,
-    args: args44,
-    tool: async (client, args45, ctx) => {
-      const [result, apiCall] = await paymentLinksUpdate(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args47,
+    tool: async (client, args48, ctx) => {
+      const [result, apiCall] = await paymentLinksUpdate(client, args48.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53782,9 +54571,9 @@ Certain details of an existing payment link can be updated.`,
 
 // src/funcs/paymentsCancel.ts
 function paymentsCancel(client, request, options) {
-  return new APIPromise($do45(client, request, options));
+  return new APIPromise($do48(client, request, options));
 }
-async function $do45(client, request, options) {
+async function $do48(client, request, options) {
   const parsed = safeParse(request, (value) => CancelPaymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -53875,12 +54664,12 @@ var init_paymentsCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentsCancel.ts
-var args45, tool$paymentsCancel;
+var args48, tool$paymentsCancel;
 var init_paymentsCancel2 = __esm(() => {
   init_paymentsCancel();
   init_operations();
   init_tools();
-  args45 = {
+  args48 = {
     request: CancelPaymentRequest$inboundSchema
   };
   tool$paymentsCancel = {
@@ -53893,9 +54682,9 @@ the next business day or as long as the payment status is open.
 Payments may also be canceled manually from the Mollie Dashboard.
 
 The \`isCancelable\` property on the [Payment object](get-payment) will indicate if the payment can be canceled.`,
-    args: args45,
-    tool: async (client, args46, ctx) => {
-      const [result, apiCall] = await paymentsCancel(client, args46.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args48,
+    tool: async (client, args49, ctx) => {
+      const [result, apiCall] = await paymentsCancel(client, args49.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53910,9 +54699,9 @@ The \`isCancelable\` property on the [Payment object](get-payment) will indicate
 
 // src/funcs/paymentsCreate.ts
 function paymentsCreate(client, request, options) {
-  return new APIPromise($do46(client, request, options));
+  return new APIPromise($do49(client, request, options));
 }
-async function $do46(client, request, options) {
+async function $do49(client, request, options) {
   const parsed = safeParse(request, (value) => CreatePaymentRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54005,12 +54794,12 @@ var init_paymentsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentsCreate.ts
-var args46, tool$paymentsCreate;
+var args49, tool$paymentsCreate;
 var init_paymentsCreate2 = __esm(() => {
   init_paymentsCreate();
   init_operations();
   init_tools();
-  args46 = {
+  args49 = {
     request: CreatePaymentRequest$inboundSchema.optional()
   };
   tool$paymentsCreate = {
@@ -54029,9 +54818,9 @@ can be found in the 'Accepting payments' guide.
 If you specify the \`method\` parameter when creating a payment, optional
 additional parameters may be available for the payment method that are not listed below. Please refer to the
 guide on [method-specific parameters](extra-payment-parameters).`,
-    args: args46,
-    tool: async (client, args47, ctx) => {
-      const [result, apiCall] = await paymentsCreate(client, args47.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args49,
+    tool: async (client, args50, ctx) => {
+      const [result, apiCall] = await paymentsCreate(client, args50.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54046,9 +54835,9 @@ guide on [method-specific parameters](extra-payment-parameters).`,
 
 // src/funcs/paymentsGet.ts
 function paymentsGet(client, request, options) {
-  return new APIPromise($do47(client, request, options));
+  return new APIPromise($do50(client, request, options));
 }
-async function $do47(client, request, options) {
+async function $do50(client, request, options) {
   const parsed = safeParse(request, (value) => GetPaymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54144,12 +54933,12 @@ var init_paymentsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentsGet.ts
-var args47, tool$paymentsGet;
+var args50, tool$paymentsGet;
 var init_paymentsGet2 = __esm(() => {
   init_paymentsGet();
   init_operations();
   init_tools();
-  args47 = {
+  args50 = {
     request: GetPaymentRequest$inboundSchema
   };
   tool$paymentsGet = {
@@ -54157,9 +54946,9 @@ var init_paymentsGet2 = __esm(() => {
     description: `Get payment
 
 Retrieve a single payment object by its payment ID.`,
-    args: args47,
-    tool: async (client, args48, ctx) => {
-      const [result, apiCall] = await paymentsGet(client, args48.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args50,
+    tool: async (client, args51, ctx) => {
+      const [result, apiCall] = await paymentsGet(client, args51.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54174,9 +54963,9 @@ Retrieve a single payment object by its payment ID.`,
 
 // src/funcs/paymentsList.ts
 function paymentsList(client, request, options) {
-  return new APIPromise($do48(client, request, options));
+  return new APIPromise($do51(client, request, options));
 }
-async function $do48(client, request, options) {
+async function $do51(client, request, options) {
   const parsed = safeParse(request, (value) => ListPaymentsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54267,12 +55056,12 @@ var init_paymentsList = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentsList.ts
-var args48, tool$paymentsList;
+var args51, tool$paymentsList;
 var init_paymentsList2 = __esm(() => {
   init_paymentsList();
   init_operations();
   init_tools();
-  args48 = {
+  args51 = {
     request: ListPaymentsRequest$inboundSchema.optional()
   };
   tool$paymentsList = {
@@ -54282,9 +55071,9 @@ var init_paymentsList2 = __esm(() => {
 Retrieve all payments created with the current website profile.
 
 The results are paginated.`,
-    args: args48,
-    tool: async (client, args49, ctx) => {
-      const [result, apiCall] = await paymentsList(client, args49.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args51,
+    tool: async (client, args52, ctx) => {
+      const [result, apiCall] = await paymentsList(client, args52.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54299,9 +55088,9 @@ The results are paginated.`,
 
 // src/funcs/paymentsReleaseAuthorization.ts
 function paymentsReleaseAuthorization(client, request, options) {
-  return new APIPromise($do49(client, request, options));
+  return new APIPromise($do52(client, request, options));
 }
-async function $do49(client, request, options) {
+async function $do52(client, request, options) {
   const parsed = safeParse(request, (value) => ReleaseAuthorizationRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54390,12 +55179,12 @@ var init_paymentsReleaseAuthorization = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentsReleaseAuthorization.ts
-var args49, tool$paymentsReleaseAuthorization;
+var args52, tool$paymentsReleaseAuthorization;
 var init_paymentsReleaseAuthorization2 = __esm(() => {
   init_paymentsReleaseAuthorization();
   init_operations();
   init_tools();
-  args49 = {
+  args52 = {
     request: ReleaseAuthorizationRequest$inboundSchema
   };
   tool$paymentsReleaseAuthorization = {
@@ -54410,9 +55199,9 @@ the issuing bank if and when the hold will be released.
 
 If the request does succeed, the payment status will change to \`canceled\` for payments without captures.
 If there is a successful capture, the payment will transition to \`paid\`.`,
-    args: args49,
-    tool: async (client, args50, ctx) => {
-      const [result, apiCall] = await paymentsReleaseAuthorization(client, args50.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args52,
+    tool: async (client, args53, ctx) => {
+      const [result, apiCall] = await paymentsReleaseAuthorization(client, args53.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54427,9 +55216,9 @@ If there is a successful capture, the payment will transition to \`paid\`.`,
 
 // src/funcs/paymentsUpdate.ts
 function paymentsUpdate(client, request, options) {
-  return new APIPromise($do50(client, request, options));
+  return new APIPromise($do53(client, request, options));
 }
-async function $do50(client, request, options) {
+async function $do53(client, request, options) {
   const parsed = safeParse(request, (value) => UpdatePaymentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54520,12 +55309,12 @@ var init_paymentsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/paymentsUpdate.ts
-var args50, tool$paymentsUpdate;
+var args53, tool$paymentsUpdate;
 var init_paymentsUpdate2 = __esm(() => {
   init_paymentsUpdate();
   init_operations();
   init_tools();
-  args50 = {
+  args53 = {
     request: UpdatePaymentRequest$inboundSchema
   };
   tool$paymentsUpdate = {
@@ -54535,9 +55324,9 @@ var init_paymentsUpdate2 = __esm(() => {
 Certain details of an existing payment can be updated.
 
 Updating the payment details will not result in a webhook call.`,
-    args: args50,
-    tool: async (client, args51, ctx) => {
-      const [result, apiCall] = await paymentsUpdate(client, args51.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args53,
+    tool: async (client, args54, ctx) => {
+      const [result, apiCall] = await paymentsUpdate(client, args54.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54552,9 +55341,9 @@ Updating the payment details will not result in a webhook call.`,
 
 // src/funcs/permissionsGet.ts
 function permissionsGet(client, request, options) {
-  return new APIPromise($do51(client, request, options));
+  return new APIPromise($do54(client, request, options));
 }
-async function $do51(client, request, options) {
+async function $do54(client, request, options) {
   const parsed = safeParse(request, (value) => GetPermissionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54648,12 +55437,12 @@ var init_permissionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsGet.ts
-var args51, tool$permissionsGet;
+var args54, tool$permissionsGet;
 var init_permissionsGet2 = __esm(() => {
   init_permissionsGet();
   init_operations();
   init_tools();
-  args51 = {
+  args54 = {
     request: GetPermissionRequest$inboundSchema
   };
   tool$permissionsGet = {
@@ -54661,9 +55450,9 @@ var init_permissionsGet2 = __esm(() => {
     description: `Get permission
 
 Retrieve a single permission by its ID, and see if the permission is granted to the current access token.`,
-    args: args51,
-    tool: async (client, args52, ctx) => {
-      const [result, apiCall] = await permissionsGet(client, args52.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args54,
+    tool: async (client, args55, ctx) => {
+      const [result, apiCall] = await permissionsGet(client, args55.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54678,9 +55467,9 @@ Retrieve a single permission by its ID, and see if the permission is granted to
 
 // src/funcs/permissionsList.ts
 function permissionsList(client, request, options) {
-  return new APIPromise($do52(client, request, options));
+  return new APIPromise($do55(client, request, options));
 }
-async function $do52(client, request, options) {
+async function $do55(client, request, options) {
   const parsed = safeParse(request, (value) => ListPermissionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54763,12 +55552,12 @@ var init_permissionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsList.ts
-var args52, tool$permissionsList;
+var args55, tool$permissionsList;
 var init_permissionsList2 = __esm(() => {
   init_permissionsList();
   init_operations();
   init_tools();
-  args52 = {
+  args55 = {
     request: ListPermissionsRequest$inboundSchema.optional()
   };
   tool$permissionsList = {
@@ -54778,9 +55567,9 @@ var init_permissionsList2 = __esm(() => {
 Retrieve a list of all permissions available to the current access token.
 
 The results are **not** paginated.`,
-    args: args52,
-    tool: async (client, args53, ctx) => {
-      const [result, apiCall] = await permissionsList(client, args53.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args55,
+    tool: async (client, args56, ctx) => {
+      const [result, apiCall] = await permissionsList(client, args56.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54795,9 +55584,9 @@ The results are **not** paginated.`,
 
 // src/funcs/profilesCreate.ts
 function profilesCreate(client, request, options) {
-  return new APIPromise($do53(client, request, options));
+  return new APIPromise($do56(client, request, options));
 }
-async function $do53(client, request, options) {
+async function $do56(client, request, options) {
   const parsed = safeParse(request, (value) => CreateProfileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -54882,12 +55671,12 @@ var init_profilesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/profilesCreate.ts
-var args53, tool$profilesCreate;
+var args56, tool$profilesCreate;
 var init_profilesCreate2 = __esm(() => {
   init_profilesCreate();
   init_operations();
   init_tools();
-  args53 = {
+  args56 = {
     request: CreateProfileRequest$inboundSchema
   };
   tool$profilesCreate = {
@@ -54898,9 +55687,9 @@ Create a profile to process payments on.
 
 Profiles are required for payment processing. Normally they are created via the Mollie dashboard. Alternatively, you
 can use this endpoint to automate profile creation.`,
-    args: args53,
-    tool: async (client, args54, ctx) => {
-      const [result, apiCall] = await profilesCreate(client, args54.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args56,
+    tool: async (client, args57, ctx) => {
+      const [result, apiCall] = await profilesCreate(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54915,9 +55704,9 @@ can use this endpoint to automate profile creation.`,
 
 // src/funcs/profilesDelete.ts
 function profilesDelete(client, request, options) {
-  return new APIPromise($do54(client, request, options));
+  return new APIPromise($do57(client, request, options));
 }
-async function $do54(client, request, options) {
+async function $do57(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteProfileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55005,12 +55794,12 @@ var init_profilesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/profilesDelete.ts
-var args54, tool$profilesDelete;
+var args57, tool$profilesDelete;
 var init_profilesDelete2 = __esm(() => {
   init_profilesDelete();
   init_operations();
   init_tools();
-  args54 = {
+  args57 = {
     request: DeleteProfileRequest$inboundSchema
   };
   tool$profilesDelete = {
@@ -55018,9 +55807,9 @@ var init_profilesDelete2 = __esm(() => {
     description: `Delete profile
 
 Delete a profile. A deleted profile and its related credentials can no longer be used for accepting payments.`,
-    args: args54,
-    tool: async (client, args55, ctx) => {
-      const [result, apiCall] = await profilesDelete(client, args55.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args57,
+    tool: async (client, args58, ctx) => {
+      const [result, apiCall] = await profilesDelete(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55035,9 +55824,9 @@ Delete a profile. A deleted profile and its related credentials can no longer be
 
 // src/funcs/profilesGet.ts
 function profilesGet(client, request, options) {
-  return new APIPromise($do55(client, request, options));
+  return new APIPromise($do58(client, request, options));
 }
-async function $do55(client, request, options) {
+async function $do58(client, request, options) {
   const parsed = safeParse(request, (value) => GetProfileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55131,12 +55920,12 @@ var init_profilesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/profilesGet.ts
-var args55, tool$profilesGet;
+var args58, tool$profilesGet;
 var init_profilesGet2 = __esm(() => {
   init_profilesGet();
   init_operations();
   init_tools();
-  args55 = {
+  args58 = {
     request: GetProfileRequest$inboundSchema
   };
   tool$profilesGet = {
@@ -55144,9 +55933,9 @@ var init_profilesGet2 = __esm(() => {
     description: `Get profile
 
 Retrieve a single profile by its ID.`,
-    args: args55,
-    tool: async (client, args56, ctx) => {
-      const [result, apiCall] = await profilesGet(client, args56.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args58,
+    tool: async (client, args59, ctx) => {
+      const [result, apiCall] = await profilesGet(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55161,9 +55950,9 @@ Retrieve a single profile by its ID.`,
 
 // src/funcs/profilesGetCurrent.ts
 function profilesGetCurrent(client, request, options) {
-  return new APIPromise($do56(client, request, options));
+  return new APIPromise($do59(client, request, options));
 }
-async function $do56(client, request, options) {
+async function $do59(client, request, options) {
   const parsed = safeParse(request, (value) => GetCurrentProfileRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55241,12 +56030,12 @@ var init_profilesGetCurrent = __esm(() => {
 });
 
 // src/mcp-server/tools/profilesGetCurrent.ts
-var args56, tool$profilesGetCurrent;
+var args59, tool$profilesGetCurrent;
 var init_profilesGetCurrent2 = __esm(() => {
   init_profilesGetCurrent();
   init_operations();
   init_tools();
-  args56 = {
+  args59 = {
     request: GetCurrentProfileRequest$inboundSchema.optional()
   };
   tool$profilesGetCurrent = {
@@ -55258,9 +56047,9 @@ endpoint.
 
 For a complete reference of the profile object, refer to the [Get profile](get-profile) endpoint
 documentation.`,
-    args: args56,
-    tool: async (client, args57, ctx) => {
-      const [result, apiCall] = await profilesGetCurrent(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args59,
+    tool: async (client, args60, ctx) => {
+      const [result, apiCall] = await profilesGetCurrent(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55275,9 +56064,9 @@ documentation.`,
 
 // src/funcs/profilesList.ts
 function profilesList(client, request, options) {
-  return new APIPromise($do57(client, request, options));
+  return new APIPromise($do60(client, request, options));
 }
-async function $do57(client, request, options) {
+async function $do60(client, request, options) {
   const parsed = safeParse(request, (value) => ListProfilesRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55365,12 +56154,12 @@ var init_profilesList = __esm(() => {
 });
 
 // src/mcp-server/tools/profilesList.ts
-var args57, tool$profilesList;
+var args60, tool$profilesList;
 var init_profilesList2 = __esm(() => {
   init_profilesList();
   init_operations();
   init_tools();
-  args57 = {
+  args60 = {
     request: ListProfilesRequest$inboundSchema.optional()
   };
   tool$profilesList = {
@@ -55380,9 +56169,9 @@ var init_profilesList2 = __esm(() => {
 Retrieve a list of all of your profiles.
 
 The results are paginated.`,
-    args: args57,
-    tool: async (client, args58, ctx) => {
-      const [result, apiCall] = await profilesList(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args60,
+    tool: async (client, args61, ctx) => {
+      const [result, apiCall] = await profilesList(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55397,9 +56186,9 @@ The results are paginated.`,
 
 // src/funcs/profilesUpdate.ts
 function profilesUpdate(client, request, options) {
-  return new APIPromise($do58(client, request, options));
+  return new APIPromise($do61(client, request, options));
 }
-async function $do58(client, request, options) {
+async function $do61(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateProfileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55490,12 +56279,12 @@ var init_profilesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/profilesUpdate.ts
-var args58, tool$profilesUpdate;
+var args61, tool$profilesUpdate;
 var init_profilesUpdate2 = __esm(() => {
   init_profilesUpdate();
   init_operations();
   init_tools();
-  args58 = {
+  args61 = {
     request: UpdateProfileRequest$inboundSchema
   };
   tool$profilesUpdate = {
@@ -55506,9 +56295,9 @@ Update an existing profile.
 
 Profiles are required for payment processing. Normally they are created and updated via the Mollie dashboard.
 Alternatively, you can use this endpoint to automate profile management.`,
-    args: args58,
-    tool: async (client, args59, ctx) => {
-      const [result, apiCall] = await profilesUpdate(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args61,
+    tool: async (client, args62, ctx) => {
+      const [result, apiCall] = await profilesUpdate(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55523,9 +56312,9 @@ Alternatively, you can use this endpoint to automate profile management.`,
 
 // src/funcs/refundsAll.ts
 function refundsAll(client, request, options) {
-  return new APIPromise($do59(client, request, options));
+  return new APIPromise($do62(client, request, options));
 }
-async function $do59(client, request, options) {
+async function $do62(client, request, options) {
   const parsed = safeParse(request, (value) => ListAllRefundsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55617,12 +56406,12 @@ var init_refundsAll = __esm(() => {
 });
 
 // src/mcp-server/tools/refundsAll.ts
-var args59, tool$refundsAll;
+var args62, tool$refundsAll;
 var init_refundsAll2 = __esm(() => {
   init_refundsAll();
   init_operations();
   init_tools();
-  args59 = {
+  args62 = {
     request: ListAllRefundsRequest$inboundSchema.optional()
   };
   tool$refundsAll = {
@@ -55632,9 +56421,9 @@ var init_refundsAll2 = __esm(() => {
 Retrieve a list of all of your refunds.
 
 The results are paginated.`,
-    args: args59,
-    tool: async (client, args60, ctx) => {
-      const [result, apiCall] = await refundsAll(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args62,
+    tool: async (client, args63, ctx) => {
+      const [result, apiCall] = await refundsAll(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55649,9 +56438,9 @@ The results are paginated.`,
 
 // src/funcs/refundsCancel.ts
 function refundsCancel(client, request, options) {
-  return new APIPromise($do60(client, request, options));
+  return new APIPromise($do63(client, request, options));
 }
-async function $do60(client, request, options) {
+async function $do63(client, request, options) {
   const parsed = safeParse(request, (value) => CancelRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55747,12 +56536,12 @@ var init_refundsCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/refundsCancel.ts
-var args60, tool$refundsCancel;
+var args63, tool$refundsCancel;
 var init_refundsCancel2 = __esm(() => {
   init_refundsCancel();
   init_operations();
   init_tools();
-  args60 = {
+  args63 = {
     request: CancelRefundRequest$inboundSchema
   };
   tool$refundsCancel = {
@@ -55764,9 +56553,9 @@ Mollie Dashboard, or by using this endpoint.
 
 A refund can only be canceled while its \`status\` field is either \`queued\` or \`pending\`. See the
 [Get refund endpoint](get-refund) for more information.`,
-    args: args60,
-    tool: async (client, args61, ctx) => {
-      const [result, apiCall] = await refundsCancel(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args63,
+    tool: async (client, args64, ctx) => {
+      const [result, apiCall] = await refundsCancel(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55781,9 +56570,9 @@ A refund can only be canceled while its \`status\` field is either \`queued\` or
 
 // src/funcs/refundsCreate.ts
 function refundsCreate(client, request, options) {
-  return new APIPromise($do61(client, request, options));
+  return new APIPromise($do64(client, request, options));
 }
-async function $do61(client, request, options) {
+async function $do64(client, request, options) {
   const parsed = safeParse(request, (value) => CreateRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -55874,12 +56663,12 @@ var init_refundsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/refundsCreate.ts
-var args61, tool$refundsCreate;
+var args64, tool$refundsCreate;
 var init_refundsCreate2 = __esm(() => {
   init_refundsCreate();
   init_operations();
   init_tools();
-  args61 = {
+  args64 = {
     request: CreateRefundRequest$inboundSchema
   };
   tool$refundsCreate = {
@@ -55888,9 +56677,9 @@ var init_refundsCreate2 = __esm(() => {
 
 Creates a refund for a specific payment. The refunded amount is credited to your customer usually either via a bank
 transfer or by refunding the amount to your customer's credit card.`,
-    args: args61,
-    tool: async (client, args62, ctx) => {
-      const [result, apiCall] = await refundsCreate(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args64,
+    tool: async (client, args65, ctx) => {
+      const [result, apiCall] = await refundsCreate(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55905,9 +56694,9 @@ transfer or by refunding the amount to your customer's credit card.`,
 
 // src/funcs/refundsGet.ts
 function refundsGet(client, request, options) {
-  return new APIPromise($do62(client, request, options));
+  return new APIPromise($do65(client, request, options));
 }
-async function $do62(client, request, options) {
+async function $do65(client, request, options) {
   const parsed = safeParse(request, (value) => GetRefundRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56006,12 +56795,12 @@ var init_refundsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/refundsGet.ts
-var args62, tool$refundsGet;
+var args65, tool$refundsGet;
 var init_refundsGet2 = __esm(() => {
   init_refundsGet();
   init_operations();
   init_tools();
-  args62 = {
+  args65 = {
     request: GetRefundRequest$inboundSchema
   };
   tool$refundsGet = {
@@ -56019,9 +56808,9 @@ var init_refundsGet2 = __esm(() => {
     description: `Get payment refund
 
 Retrieve a single payment refund by its ID and the ID of its parent payment.`,
-    args: args62,
-    tool: async (client, args63, ctx) => {
-      const [result, apiCall] = await refundsGet(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args65,
+    tool: async (client, args66, ctx) => {
+      const [result, apiCall] = await refundsGet(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56036,9 +56825,9 @@ Retrieve a single payment refund by its ID and the ID of its parent payment.`,
 
 // src/funcs/refundsList.ts
 function refundsList(client, request, options) {
-  return new APIPromise($do63(client, request, options));
+  return new APIPromise($do66(client, request, options));
 }
-async function $do63(client, request, options) {
+async function $do66(client, request, options) {
   const parsed = safeParse(request, (value) => ListRefundsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56134,12 +56923,12 @@ var init_refundsList = __esm(() => {
 });
 
 // src/mcp-server/tools/refundsList.ts
-var args63, tool$refundsList;
+var args66, tool$refundsList;
 var init_refundsList2 = __esm(() => {
   init_refundsList();
   init_operations();
   init_tools();
-  args63 = {
+  args66 = {
     request: ListRefundsRequest$inboundSchema
   };
   tool$refundsList = {
@@ -56149,9 +56938,9 @@ var init_refundsList2 = __esm(() => {
 Retrieve a list of all refunds created for a specific payment.
 
 The results are paginated.`,
-    args: args63,
-    tool: async (client, args64, ctx) => {
-      const [result, apiCall] = await refundsList(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args66,
+    tool: async (client, args67, ctx) => {
+      const [result, apiCall] = await refundsList(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56166,9 +56955,9 @@ The results are paginated.`,
 
 // src/funcs/salesInvoicesCreate.ts
 function salesInvoicesCreate(client, request, options) {
-  return new APIPromise($do64(client, request, options));
+  return new APIPromise($do67(client, request, options));
 }
-async function $do64(client, request, options) {
+async function $do67(client, request, options) {
   const parsed = safeParse(request, (value) => CreateSalesInvoiceRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56255,12 +57044,12 @@ var init_salesInvoicesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/salesInvoicesCreate.ts
-var args64, tool$salesInvoicesCreate;
+var args67, tool$salesInvoicesCreate;
 var init_salesInvoicesCreate2 = __esm(() => {
   init_salesInvoicesCreate();
   init_operations();
   init_tools();
-  args64 = {
+  args67 = {
     request: CreateSalesInvoiceRequest$inboundSchema.optional()
   };
   tool$salesInvoicesCreate = {
@@ -56272,9 +57061,9 @@ var init_salesInvoicesCreate2 = __esm(() => {
 > This feature is currently in beta testing, and the final specification may still change.
 
 With the Sales Invoice API you can generate sales invoices to send to your customers.`,
-    args: args64,
-    tool: async (client, args65, ctx) => {
-      const [result, apiCall] = await salesInvoicesCreate(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args67,
+    tool: async (client, args68, ctx) => {
+      const [result, apiCall] = await salesInvoicesCreate(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56289,9 +57078,9 @@ With the Sales Invoice API you can generate sales invoices to send to your custo
 
 // src/funcs/salesInvoicesDelete.ts
 function salesInvoicesDelete(client, request, options) {
-  return new APIPromise($do65(client, request, options));
+  return new APIPromise($do68(client, request, options));
 }
-async function $do65(client, request, options) {
+async function $do68(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteSalesInvoiceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56382,12 +57171,12 @@ var init_salesInvoicesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/salesInvoicesDelete.ts
-var args65, tool$salesInvoicesDelete;
+var args68, tool$salesInvoicesDelete;
 var init_salesInvoicesDelete2 = __esm(() => {
   init_salesInvoicesDelete();
   init_operations();
   init_tools();
-  args65 = {
+  args68 = {
     request: DeleteSalesInvoiceRequest$inboundSchema
   };
   tool$salesInvoicesDelete = {
@@ -56400,9 +57189,9 @@ var init_salesInvoicesDelete2 = __esm(() => {
 
 Sales invoices which are in status \`draft\` can be deleted. For all other statuses, please use the
 [Update sales invoice](update-sales-invoice) endpoint instead.`,
-    args: args65,
-    tool: async (client, args66, ctx) => {
-      const [result, apiCall] = await salesInvoicesDelete(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args68,
+    tool: async (client, args69, ctx) => {
+      const [result, apiCall] = await salesInvoicesDelete(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56417,9 +57206,9 @@ Sales invoices which are in status \`draft\` can be deleted. For all other statu
 
 // src/funcs/salesInvoicesGet.ts
 function salesInvoicesGet(client, request, options) {
-  return new APIPromise($do66(client, request, options));
+  return new APIPromise($do69(client, request, options));
 }
-async function $do66(client, request, options) {
+async function $do69(client, request, options) {
   const parsed = safeParse(request, (value) => GetSalesInvoiceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56513,12 +57302,12 @@ var init_salesInvoicesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/salesInvoicesGet.ts
-var args66, tool$salesInvoicesGet;
+var args69, tool$salesInvoicesGet;
 var init_salesInvoicesGet2 = __esm(() => {
   init_salesInvoicesGet();
   init_operations();
   init_tools();
-  args66 = {
+  args69 = {
     request: GetSalesInvoiceRequest$inboundSchema
   };
   tool$salesInvoicesGet = {
@@ -56530,9 +57319,9 @@ var init_salesInvoicesGet2 = __esm(() => {
 > This feature is currently in beta testing, and the final specification may still change.
 
 Retrieve a single sales invoice by its ID.`,
-    args: args66,
-    tool: async (client, args67, ctx) => {
-      const [result, apiCall] = await salesInvoicesGet(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args69,
+    tool: async (client, args70, ctx) => {
+      const [result, apiCall] = await salesInvoicesGet(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56547,9 +57336,9 @@ Retrieve a single sales invoice by its ID.`,
 
 // src/funcs/salesInvoicesList.ts
 function salesInvoicesList(client, request, options) {
-  return new APIPromise($do67(client, request, options));
+  return new APIPromise($do70(client, request, options));
 }
-async function $do67(client, request, options) {
+async function $do70(client, request, options) {
   const parsed = safeParse(request, (value) => ListSalesInvoicesRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56638,12 +57427,12 @@ var init_salesInvoicesList = __esm(() => {
 });
 
 // src/mcp-server/tools/salesInvoicesList.ts
-var args67, tool$salesInvoicesList;
+var args70, tool$salesInvoicesList;
 var init_salesInvoicesList2 = __esm(() => {
   init_salesInvoicesList();
   init_operations();
   init_tools();
-  args67 = {
+  args70 = {
     request: ListSalesInvoicesRequest$inboundSchema.optional()
   };
   tool$salesInvoicesList = {
@@ -56657,9 +57446,9 @@ var init_salesInvoicesList2 = __esm(() => {
 Retrieve a list of all sales invoices created through the API.
 
 The results are paginated.`,
-    args: args67,
-    tool: async (client, args68, ctx) => {
-      const [result, apiCall] = await salesInvoicesList(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args70,
+    tool: async (client, args71, ctx) => {
+      const [result, apiCall] = await salesInvoicesList(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56674,9 +57463,9 @@ The results are paginated.`,
 
 // src/funcs/salesInvoicesUpdate.ts
 function salesInvoicesUpdate(client, request, options) {
-  return new APIPromise($do68(client, request, options));
+  return new APIPromise($do71(client, request, options));
 }
-async function $do68(client, request, options) {
+async function $do71(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateSalesInvoiceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56769,12 +57558,12 @@ var init_salesInvoicesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/salesInvoicesUpdate.ts
-var args68, tool$salesInvoicesUpdate;
+var args71, tool$salesInvoicesUpdate;
 var init_salesInvoicesUpdate2 = __esm(() => {
   init_salesInvoicesUpdate();
   init_operations();
   init_tools();
-  args68 = {
+  args71 = {
     request: UpdateSalesInvoiceRequest$inboundSchema
   };
   tool$salesInvoicesUpdate = {
@@ -56788,9 +57577,9 @@ var init_salesInvoicesUpdate2 = __esm(() => {
 Certain details of an existing sales invoice can be updated. For \`draft\` it is all values listed below, but for
 statuses \`paid\` and \`issued\` there are certain additional requirements (\`paymentDetails\` and \`emailDetails\`,
 respectively).`,
-    args: args68,
-    tool: async (client, args69, ctx) => {
-      const [result, apiCall] = await salesInvoicesUpdate(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args71,
+    tool: async (client, args72, ctx) => {
+      const [result, apiCall] = await salesInvoicesUpdate(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56805,9 +57594,9 @@ respectively).`,
 
 // src/funcs/settlementsGet.ts
 function settlementsGet(client, request, options) {
-  return new APIPromise($do69(client, request, options));
+  return new APIPromise($do72(client, request, options));
 }
-async function $do69(client, request, options) {
+async function $do72(client, request, options) {
   const parsed = safeParse(request, (value) => GetSettlementRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -56897,12 +57686,12 @@ var init_settlementsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/settlementsGet.ts
-var args69, tool$settlementsGet;
+var args72, tool$settlementsGet;
 var init_settlementsGet2 = __esm(() => {
   init_settlementsGet();
   init_operations();
   init_tools();
-  args69 = {
+  args72 = {
     request: GetSettlementRequest$inboundSchema
   };
   tool$settlementsGet = {
@@ -56921,9 +57710,9 @@ settlement and the previous one.
 
 For more accurate bookkeeping, refer to the [balance report](get-balance-report) endpoint or the
 [balance transactions](list-balance-transactions) endpoint.`,
-    args: args69,
-    tool: async (client, args70, ctx) => {
-      const [result, apiCall] = await settlementsGet(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args72,
+    tool: async (client, args73, ctx) => {
+      const [result, apiCall] = await settlementsGet(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -56938,9 +57727,9 @@ For more accurate bookkeeping, refer to the [balance report](get-balance-report)
 
 // src/funcs/settlementsGetNext.ts
 function settlementsGetNext(client, request, options) {
-  return new APIPromise($do70(client, request, options));
+  return new APIPromise($do73(client, request, options));
 }
-async function $do70(client, request, options) {
+async function $do73(client, request, options) {
   const parsed = safeParse(request, (value) => GetNextSettlementRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57018,12 +57807,12 @@ var init_settlementsGetNext = __esm(() => {
 });
 
 // src/mcp-server/tools/settlementsGetNext.ts
-var args70, tool$settlementsGetNext;
+var args73, tool$settlementsGetNext;
 var init_settlementsGetNext2 = __esm(() => {
   init_settlementsGetNext();
   init_operations();
   init_tools();
-  args70 = {
+  args73 = {
     request: GetNextSettlementRequest$inboundSchema.optional()
   };
   tool$settlementsGetNext = {
@@ -57037,9 +57826,9 @@ documentation.
 
 For more accurate bookkeeping, refer to the [balance report](get-balance-report) endpoint or the
 [balance transactions](list-balance-transactions) endpoint.`,
-    args: args70,
-    tool: async (client, args71, ctx) => {
-      const [result, apiCall] = await settlementsGetNext(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args73,
+    tool: async (client, args74, ctx) => {
+      const [result, apiCall] = await settlementsGetNext(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57054,9 +57843,9 @@ For more accurate bookkeeping, refer to the [balance report](get-balance-report)
 
 // src/funcs/settlementsGetOpen.ts
 function settlementsGetOpen(client, request, options) {
-  return new APIPromise($do71(client, request, options));
+  return new APIPromise($do74(client, request, options));
 }
-async function $do71(client, request, options) {
+async function $do74(client, request, options) {
   const parsed = safeParse(request, (value) => GetOpenSettlementRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57134,12 +57923,12 @@ var init_settlementsGetOpen = __esm(() => {
 });
 
 // src/mcp-server/tools/settlementsGetOpen.ts
-var args71, tool$settlementsGetOpen;
+var args74, tool$settlementsGetOpen;
 var init_settlementsGetOpen2 = __esm(() => {
   init_settlementsGetOpen();
   init_operations();
   init_tools();
-  args71 = {
+  args74 = {
     request: GetOpenSettlementRequest$inboundSchema.optional()
   };
   tool$settlementsGetOpen = {
@@ -57154,9 +57943,9 @@ documentation.
 
 For more accurate bookkeeping, refer to the [balance report](get-balance-report) endpoint or the
 [balance transactions](list-balance-transactions) endpoint.`,
-    args: args71,
-    tool: async (client, args72, ctx) => {
-      const [result, apiCall] = await settlementsGetOpen(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args74,
+    tool: async (client, args75, ctx) => {
+      const [result, apiCall] = await settlementsGetOpen(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57171,9 +57960,9 @@ For more accurate bookkeeping, refer to the [balance report](get-balance-report)
 
 // src/funcs/settlementsList.ts
 function settlementsList(client, request, options) {
-  return new APIPromise($do72(client, request, options));
+  return new APIPromise($do75(client, request, options));
 }
-async function $do72(client, request, options) {
+async function $do75(client, request, options) {
   const parsed = safeParse(request, (value) => ListSettlementsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57265,12 +58054,12 @@ var init_settlementsList = __esm(() => {
 });
 
 // src/mcp-server/tools/settlementsList.ts
-var args72, tool$settlementsList;
+var args75, tool$settlementsList;
 var init_settlementsList2 = __esm(() => {
   init_settlementsList();
   init_operations();
   init_tools();
-  args72 = {
+  args75 = {
     request: ListSettlementsRequest$inboundSchema.optional()
   };
   tool$settlementsList = {
@@ -57280,9 +58069,9 @@ var init_settlementsList2 = __esm(() => {
 Retrieve a list of all your settlements.
 
 The results are paginated.`,
-    args: args72,
-    tool: async (client, args73, ctx) => {
-      const [result, apiCall] = await settlementsList(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args75,
+    tool: async (client, args76, ctx) => {
+      const [result, apiCall] = await settlementsList(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57297,9 +58086,9 @@ The results are paginated.`,
 
 // src/funcs/settlementsListCaptures.ts
 function settlementsListCaptures(client, request, options) {
-  return new APIPromise($do73(client, request, options));
+  return new APIPromise($do76(client, request, options));
 }
-async function $do73(client, request, options) {
+async function $do76(client, request, options) {
   const parsed = safeParse(request, (value) => ListSettlementCapturesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57395,12 +58184,12 @@ var init_settlementsListCaptures = __esm(() => {
 });
 
 // src/mcp-server/tools/settlementsListCaptures.ts
-var args73, tool$settlementsListCaptures;
+var args76, tool$settlementsListCaptures;
 var init_settlementsListCaptures2 = __esm(() => {
   init_settlementsListCaptures();
   init_operations();
   init_tools();
-  args73 = {
+  args76 = {
     request: ListSettlementCapturesRequest$inboundSchema
   };
   tool$settlementsListCaptures = {
@@ -57410,9 +58199,9 @@ var init_settlementsListCaptures2 = __esm(() => {
 Retrieve all captures included in the given settlement.
 
 The response is in the same format as the response of the [List captures endpoint](list-captures).`,
-    args: args73,
-    tool: async (client, args74, ctx) => {
-      const [result, apiCall] = await settlementsListCaptures(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args76,
+    tool: async (client, args77, ctx) => {
+      const [result, apiCall] = await settlementsListCaptures(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57427,9 +58216,9 @@ The response is in the same format as the response of the [List captures endpoin
 
 // src/funcs/settlementsListChargebacks.ts
 function settlementsListChargebacks(client, request, options) {
-  return new APIPromise($do74(client, request, options));
+  return new APIPromise($do77(client, request, options));
 }
-async function $do74(client, request, options) {
+async function $do77(client, request, options) {
   const parsed = safeParse(request, (value) => ListSettlementChargebacksRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57525,12 +58314,12 @@ var init_settlementsListChargebacks = __esm(() => {
 });
 
 // src/mcp-server/tools/settlementsListChargebacks.ts
-var args74, tool$settlementsListChargebacks;
+var args77, tool$settlementsListChargebacks;
 var init_settlementsListChargebacks2 = __esm(() => {
   init_settlementsListChargebacks();
   init_operations();
   init_tools();
-  args74 = {
+  args77 = {
     request: ListSettlementChargebacksRequest$inboundSchema
   };
   tool$settlementsListChargebacks = {
@@ -57540,9 +58329,9 @@ var init_settlementsListChargebacks2 = __esm(() => {
 Retrieve all chargebacks 'deducted' from the given settlement.
 
 The response is in the same format as the response of the [List chargebacks endpoint](list-chargebacks).`,
-    args: args74,
-    tool: async (client, args75, ctx) => {
-      const [result, apiCall] = await settlementsListChargebacks(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args77,
+    tool: async (client, args78, ctx) => {
+      const [result, apiCall] = await settlementsListChargebacks(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57557,9 +58346,9 @@ The response is in the same format as the response of the [List chargebacks endp
 
 // src/funcs/settlementsListPayments.ts
 function settlementsListPayments(client, request, options) {
-  return new APIPromise($do75(client, request, options));
+  return new APIPromise($do78(client, request, options));
 }
-async function $do75(client, request, options) {
+async function $do78(client, request, options) {
   const parsed = safeParse(request, (value) => ListSettlementPaymentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57656,12 +58445,12 @@ var init_settlementsListPayments = __esm(() => {
 });
 
 // src/mcp-server/tools/settlementsListPayments.ts
-var args75, tool$settlementsListPayments;
+var args78, tool$settlementsListPayments;
 var init_settlementsListPayments2 = __esm(() => {
   init_settlementsListPayments();
   init_operations();
   init_tools();
-  args75 = {
+  args78 = {
     request: ListSettlementPaymentsRequest$inboundSchema
   };
   tool$settlementsListPayments = {
@@ -57674,9 +58463,9 @@ The response is in the same format as the response of the [List payments endpoin
 
 For capture-based payment methods such as Klarna, the payments are not listed here. Refer to the
 [List captures endpoint](list-captures) endpoint instead.`,
-    args: args75,
-    tool: async (client, args76, ctx) => {
-      const [result, apiCall] = await settlementsListPayments(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args78,
+    tool: async (client, args79, ctx) => {
+      const [result, apiCall] = await settlementsListPayments(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57691,9 +58480,9 @@ For capture-based payment methods such as Klarna, the payments are not listed he
 
 // src/funcs/settlementsListRefunds.ts
 function settlementsListRefunds(client, request, options) {
-  return new APIPromise($do76(client, request, options));
+  return new APIPromise($do79(client, request, options));
 }
-async function $do76(client, request, options) {
+async function $do79(client, request, options) {
   const parsed = safeParse(request, (value) => ListSettlementRefundsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57789,12 +58578,12 @@ var init_settlementsListRefunds = __esm(() => {
 });
 
 // src/mcp-server/tools/settlementsListRefunds.ts
-var args76, tool$settlementsListRefunds;
+var args79, tool$settlementsListRefunds;
 var init_settlementsListRefunds2 = __esm(() => {
   init_settlementsListRefunds();
   init_operations();
   init_tools();
-  args76 = {
+  args79 = {
     request: ListSettlementRefundsRequest$inboundSchema
   };
   tool$settlementsListRefunds = {
@@ -57804,9 +58593,9 @@ var init_settlementsListRefunds2 = __esm(() => {
 Retrieve all refunds 'deducted' from the given settlement.
 
 The response is in the same format as the response of the [List refunds endpoint](list-refunds).`,
-    args: args76,
-    tool: async (client, args77, ctx) => {
-      const [result, apiCall] = await settlementsListRefunds(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args79,
+    tool: async (client, args80, ctx) => {
+      const [result, apiCall] = await settlementsListRefunds(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57821,9 +58610,9 @@ The response is in the same format as the response of the [List refunds endpoint
 
 // src/funcs/subscriptionsAll.ts
 function subscriptionsAll(client, request, options) {
-  return new APIPromise($do77(client, request, options));
+  return new APIPromise($do80(client, request, options));
 }
-async function $do77(client, request, options) {
+async function $do80(client, request, options) {
   const parsed = safeParse(request, (value) => ListAllSubscriptionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -57913,12 +58702,12 @@ var init_subscriptionsAll = __esm(() => {
 });
 
 // src/mcp-server/tools/subscriptionsAll.ts
-var args77, tool$subscriptionsAll;
+var args80, tool$subscriptionsAll;
 var init_subscriptionsAll2 = __esm(() => {
   init_subscriptionsAll();
   init_operations();
   init_tools();
-  args77 = {
+  args80 = {
     request: ListAllSubscriptionsRequest$inboundSchema.optional()
   };
   tool$subscriptionsAll = {
@@ -57928,9 +58717,9 @@ var init_subscriptionsAll2 = __esm(() => {
 Retrieve all subscriptions initiated across all your customers.
 
 The results are paginated.`,
-    args: args77,
-    tool: async (client, args78, ctx) => {
-      const [result, apiCall] = await subscriptionsAll(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args80,
+    tool: async (client, args81, ctx) => {
+      const [result, apiCall] = await subscriptionsAll(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -57945,9 +58734,9 @@ The results are paginated.`,
 
 // src/funcs/subscriptionsCancel.ts
 function subscriptionsCancel(client, request, options) {
-  return new APIPromise($do78(client, request, options));
+  return new APIPromise($do81(client, request, options));
 }
-async function $do78(client, request, options) {
+async function $do81(client, request, options) {
   const parsed = safeParse(request, (value) => CancelSubscriptionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58042,12 +58831,12 @@ var init_subscriptionsCancel = __esm(() => {
 });
 
 // src/mcp-server/tools/subscriptionsCancel.ts
-var args78, tool$subscriptionsCancel;
+var args81, tool$subscriptionsCancel;
 var init_subscriptionsCancel2 = __esm(() => {
   init_subscriptionsCancel();
   init_operations();
   init_tools();
-  args78 = {
+  args81 = {
     request: CancelSubscriptionRequest$inboundSchema
   };
   tool$subscriptionsCancel = {
@@ -58055,9 +58844,9 @@ var init_subscriptionsCancel2 = __esm(() => {
     description: `Cancel subscription
 
 Cancel an existing subscription. Canceling a subscription has no effect on the mandates of the customer.`,
-    args: args78,
-    tool: async (client, args79, ctx) => {
-      const [result, apiCall] = await subscriptionsCancel(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args81,
+    tool: async (client, args82, ctx) => {
+      const [result, apiCall] = await subscriptionsCancel(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58072,9 +58861,9 @@ Cancel an existing subscription. Canceling a subscription has no effect on the m
 
 // src/funcs/subscriptionsCreate.ts
 function subscriptionsCreate(client, request, options) {
-  return new APIPromise($do79(client, request, options));
+  return new APIPromise($do82(client, request, options));
 }
-async function $do79(client, request, options) {
+async function $do82(client, request, options) {
   const parsed = safeParse(request, (value) => CreateSubscriptionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58167,12 +58956,12 @@ var init_subscriptionsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/subscriptionsCreate.ts
-var args79, tool$subscriptionsCreate;
+var args82, tool$subscriptionsCreate;
 var init_subscriptionsCreate2 = __esm(() => {
   init_subscriptionsCreate();
   init_operations();
   init_tools();
-  args79 = {
+  args82 = {
     request: CreateSubscriptionRequest$inboundSchema
   };
   tool$subscriptionsCreate = {
@@ -58198,9 +58987,9 @@ Your customer will be charged €20 every day, for five consecutive days.
 \`amount[currency]="EUR"\` \`amount[value]="10.00"\` \`interval="1 month"\`
 \`startDate="2018-04-30"\`
 Your customer will be charged €10 on the last day of each month, starting in April 2018.`,
-    args: args79,
-    tool: async (client, args80, ctx) => {
-      const [result, apiCall] = await subscriptionsCreate(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args82,
+    tool: async (client, args83, ctx) => {
+      const [result, apiCall] = await subscriptionsCreate(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58215,9 +59004,9 @@ Your customer will be charged €10 on the last day of each month, starting in A
 
 // src/funcs/subscriptionsGet.ts
 function subscriptionsGet(client, request, options) {
-  return new APIPromise($do80(client, request, options));
+  return new APIPromise($do83(client, request, options));
 }
-async function $do80(client, request, options) {
+async function $do83(client, request, options) {
   const parsed = safeParse(request, (value) => GetSubscriptionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58315,12 +59104,12 @@ var init_subscriptionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/subscriptionsGet.ts
-var args80, tool$subscriptionsGet;
+var args83, tool$subscriptionsGet;
 var init_subscriptionsGet2 = __esm(() => {
   init_subscriptionsGet();
   init_operations();
   init_tools();
-  args80 = {
+  args83 = {
     request: GetSubscriptionRequest$inboundSchema
   };
   tool$subscriptionsGet = {
@@ -58328,9 +59117,9 @@ var init_subscriptionsGet2 = __esm(() => {
     description: `Get subscription
 
 Retrieve a single subscription by its ID and the ID of its parent customer.`,
-    args: args80,
-    tool: async (client, args81, ctx) => {
-      const [result, apiCall] = await subscriptionsGet(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args83,
+    tool: async (client, args84, ctx) => {
+      const [result, apiCall] = await subscriptionsGet(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58345,9 +59134,9 @@ Retrieve a single subscription by its ID and the ID of its parent customer.`,
 
 // src/funcs/subscriptionsList.ts
 function subscriptionsList(client, request, options) {
-  return new APIPromise($do81(client, request, options));
+  return new APIPromise($do84(client, request, options));
 }
-async function $do81(client, request, options) {
+async function $do84(client, request, options) {
   const parsed = safeParse(request, (value) => ListSubscriptionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58443,12 +59232,12 @@ var init_subscriptionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/subscriptionsList.ts
-var args81, tool$subscriptionsList;
+var args84, tool$subscriptionsList;
 var init_subscriptionsList2 = __esm(() => {
   init_subscriptionsList();
   init_operations();
   init_tools();
-  args81 = {
+  args84 = {
     request: ListSubscriptionsRequest$inboundSchema
   };
   tool$subscriptionsList = {
@@ -58458,9 +59247,9 @@ var init_subscriptionsList2 = __esm(() => {
 Retrieve all subscriptions of a customer.
 
 The results are paginated.`,
-    args: args81,
-    tool: async (client, args82, ctx) => {
-      const [result, apiCall] = await subscriptionsList(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args84,
+    tool: async (client, args85, ctx) => {
+      const [result, apiCall] = await subscriptionsList(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58475,9 +59264,9 @@ The results are paginated.`,
 
 // src/funcs/subscriptionsListPayments.ts
 function subscriptionsListPayments(client, request, options) {
-  return new APIPromise($do82(client, request, options));
+  return new APIPromise($do85(client, request, options));
 }
-async function $do82(client, request, options) {
+async function $do85(client, request, options) {
   const parsed = safeParse(request, (value) => ListSubscriptionPaymentsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58578,12 +59367,12 @@ var init_subscriptionsListPayments = __esm(() => {
 });
 
 // src/mcp-server/tools/subscriptionsListPayments.ts
-var args82, tool$subscriptionsListPayments;
+var args85, tool$subscriptionsListPayments;
 var init_subscriptionsListPayments2 = __esm(() => {
   init_subscriptionsListPayments();
   init_operations();
   init_tools();
-  args82 = {
+  args85 = {
     request: ListSubscriptionPaymentsRequest$inboundSchema
   };
   tool$subscriptionsListPayments = {
@@ -58593,9 +59382,9 @@ var init_subscriptionsListPayments2 = __esm(() => {
 Retrieve all payments of a specific subscription.
 
 The results are paginated.`,
-    args: args82,
-    tool: async (client, args83, ctx) => {
-      const [result, apiCall] = await subscriptionsListPayments(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args85,
+    tool: async (client, args86, ctx) => {
+      const [result, apiCall] = await subscriptionsListPayments(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58610,9 +59399,9 @@ The results are paginated.`,
 
 // src/funcs/subscriptionsUpdate.ts
 function subscriptionsUpdate(client, request, options) {
-  return new APIPromise($do83(client, request, options));
+  return new APIPromise($do86(client, request, options));
 }
-async function $do83(client, request, options) {
+async function $do86(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateSubscriptionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58707,12 +59496,12 @@ var init_subscriptionsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/subscriptionsUpdate.ts
-var args83, tool$subscriptionsUpdate;
+var args86, tool$subscriptionsUpdate;
 var init_subscriptionsUpdate2 = __esm(() => {
   init_subscriptionsUpdate();
   init_operations();
   init_tools();
-  args83 = {
+  args86 = {
     request: UpdateSubscriptionRequest$inboundSchema
   };
   tool$subscriptionsUpdate = {
@@ -58724,9 +59513,9 @@ Update an existing subscription.
 Canceled subscriptions cannot be updated.
 
 For an in-depth explanation of each parameter, refer to the [Create subscription](create-subscription) endpoint.`,
-    args: args83,
-    tool: async (client, args84, ctx) => {
-      const [result, apiCall] = await subscriptionsUpdate(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args86,
+    tool: async (client, args87, ctx) => {
+      const [result, apiCall] = await subscriptionsUpdate(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58741,9 +59530,9 @@ For an in-depth explanation of each parameter, refer to the [Create subscription
 
 // src/funcs/terminalsGet.ts
 function terminalsGet(client, request, options) {
-  return new APIPromise($do84(client, request, options));
+  return new APIPromise($do87(client, request, options));
 }
-async function $do84(client, request, options) {
+async function $do87(client, request, options) {
   const parsed = safeParse(request, (value) => GetTerminalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58837,12 +59626,12 @@ var init_terminalsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalsGet.ts
-var args84, tool$terminalsGet;
+var args87, tool$terminalsGet;
 var init_terminalsGet2 = __esm(() => {
   init_terminalsGet();
   init_operations();
   init_tools();
-  args84 = {
+  args87 = {
     request: GetTerminalRequest$inboundSchema
   };
   tool$terminalsGet = {
@@ -58850,9 +59639,9 @@ var init_terminalsGet2 = __esm(() => {
     description: `Get terminal
 
 Retrieve a single terminal by its ID.`,
-    args: args84,
-    tool: async (client, args85, ctx) => {
-      const [result, apiCall] = await terminalsGet(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args87,
+    tool: async (client, args88, ctx) => {
+      const [result, apiCall] = await terminalsGet(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58867,9 +59656,9 @@ Retrieve a single terminal by its ID.`,
 
 // src/funcs/terminalsList.ts
 function terminalsList(client, request, options) {
-  return new APIPromise($do85(client, request, options));
+  return new APIPromise($do88(client, request, options));
 }
-async function $do85(client, request, options) {
+async function $do88(client, request, options) {
   const parsed = safeParse(request, (value) => ListTerminalsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -58959,12 +59748,12 @@ var init_terminalsList = __esm(() => {
 });
 
 // src/mcp-server/tools/terminalsList.ts
-var args85, tool$terminalsList;
+var args88, tool$terminalsList;
 var init_terminalsList2 = __esm(() => {
   init_terminalsList();
   init_operations();
   init_tools();
-  args85 = {
+  args88 = {
     request: ListTerminalsRequest$inboundSchema.optional()
   };
   tool$terminalsList = {
@@ -58974,9 +59763,9 @@ var init_terminalsList2 = __esm(() => {
 Retrieve a list of all physical point-of-sale devices.
 
 The results are paginated.`,
-    args: args85,
-    tool: async (client, args86, ctx) => {
-      const [result, apiCall] = await terminalsList(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args88,
+    tool: async (client, args89, ctx) => {
+      const [result, apiCall] = await terminalsList(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -58991,9 +59780,9 @@ The results are paginated.`,
 
 // src/funcs/walletsRequestApplePaySession.ts
 function walletsRequestApplePaySession(client, request, options) {
-  return new APIPromise($do86(client, request, options));
+  return new APIPromise($do89(client, request, options));
 }
-async function $do86(client, request, options) {
+async function $do89(client, request, options) {
   const parsed = safeParse(request, (value) => RequestApplePayPaymentSessionRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59076,12 +59865,12 @@ var init_walletsRequestApplePaySession = __esm(() => {
 });
 
 // src/mcp-server/tools/walletsRequestApplePaySession.ts
-var args86, tool$walletsRequestApplePaySession;
+var args89, tool$walletsRequestApplePaySession;
 var init_walletsRequestApplePaySession2 = __esm(() => {
   init_walletsRequestApplePaySession();
   init_operations();
   init_tools();
-  args86 = {
+  args89 = {
     request: RequestApplePayPaymentSessionRequest$inboundSchema.optional()
   };
   tool$walletsRequestApplePaySession = {
@@ -59107,9 +59896,9 @@ expire after five minutes.
 Payment sessions cannot be requested directly from the browser. The request must be sent from your server. For the
 full documentation, see the official
 [Apple Pay JS API](https://developer.apple.com/documentation/apple_pay_on_the_web/apple_pay_js_api) documentation.`,
-    args: args86,
-    tool: async (client, args87, ctx) => {
-      const [result, apiCall] = await walletsRequestApplePaySession(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args89,
+    tool: async (client, args90, ctx) => {
+      const [result, apiCall] = await walletsRequestApplePaySession(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59124,9 +59913,9 @@ full documentation, see the official
 
 // src/funcs/webhookEventsGet.ts
 function webhookEventsGet(client, request, options) {
-  return new APIPromise($do87(client, request, options));
+  return new APIPromise($do90(client, request, options));
 }
-async function $do87(client, request, options) {
+async function $do90(client, request, options) {
   const parsed = safeParse(request, (value) => GetWebhookEventRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59220,12 +60009,12 @@ var init_webhookEventsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/webhookEventsGet.ts
-var args87, tool$webhookEventsGet;
+var args90, tool$webhookEventsGet;
 var init_webhookEventsGet2 = __esm(() => {
   init_webhookEventsGet();
   init_operations();
   init_tools();
-  args87 = {
+  args90 = {
     request: GetWebhookEventRequest$inboundSchema
   };
   tool$webhookEventsGet = {
@@ -59233,9 +60022,9 @@ var init_webhookEventsGet2 = __esm(() => {
     description: `Get a Webhook Event
 
 Retrieve a single webhook event object by its event ID.`,
-    args: args87,
-    tool: async (client, args88, ctx) => {
-      const [result, apiCall] = await webhookEventsGet(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args90,
+    tool: async (client, args91, ctx) => {
+      const [result, apiCall] = await webhookEventsGet(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59250,9 +60039,9 @@ Retrieve a single webhook event object by its event ID.`,
 
 // src/funcs/webhooksCreate.ts
 function webhooksCreate(client, request, options) {
-  return new APIPromise($do88(client, request, options));
+  return new APIPromise($do91(client, request, options));
 }
-async function $do88(client, request, options) {
+async function $do91(client, request, options) {
   const parsed = safeParse(request, (value) => CreateWebhookRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59337,12 +60126,12 @@ var init_webhooksCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksCreate.ts
-var args88, tool$webhooksCreate;
+var args91, tool$webhooksCreate;
 var init_webhooksCreate2 = __esm(() => {
   init_webhooksCreate();
   init_operations();
   init_tools();
-  args88 = {
+  args91 = {
     request: CreateWebhookRequest$inboundSchema.optional()
   };
   tool$webhooksCreate = {
@@ -59350,9 +60139,9 @@ var init_webhooksCreate2 = __esm(() => {
     description: `Create a webhook
 
 A webhook must have a name, an url and a list of event types. You can also create webhooks in the webhooks settings section of the Dashboard.`,
-    args: args88,
-    tool: async (client, args89, ctx) => {
-      const [result, apiCall] = await webhooksCreate(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args91,
+    tool: async (client, args92, ctx) => {
+      const [result, apiCall] = await webhooksCreate(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59367,9 +60156,9 @@ A webhook must have a name, an url and a list of event types. You can also creat
 
 // src/funcs/webhooksDelete.ts
 function webhooksDelete(client, request, options) {
-  return new APIPromise($do89(client, request, options));
+  return new APIPromise($do92(client, request, options));
 }
-async function $do89(client, request, options) {
+async function $do92(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59458,12 +60247,12 @@ var init_webhooksDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksDelete.ts
-var args89, tool$webhooksDelete;
+var args92, tool$webhooksDelete;
 var init_webhooksDelete2 = __esm(() => {
   init_webhooksDelete();
   init_operations();
   init_tools();
-  args89 = {
+  args92 = {
     request: DeleteWebhookRequest$inboundSchema
   };
   tool$webhooksDelete = {
@@ -59471,9 +60260,9 @@ var init_webhooksDelete2 = __esm(() => {
     description: `Delete a webhook
 
 Delete a single webhook object by its webhook ID.`,
-    args: args89,
-    tool: async (client, args90, ctx) => {
-      const [result, apiCall] = await webhooksDelete(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args92,
+    tool: async (client, args93, ctx) => {
+      const [result, apiCall] = await webhooksDelete(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59488,9 +60277,9 @@ Delete a single webhook object by its webhook ID.`,
 
 // src/funcs/webhooksGet.ts
 function webhooksGet(client, request, options) {
-  return new APIPromise($do90(client, request, options));
+  return new APIPromise($do93(client, request, options));
 }
-async function $do90(client, request, options) {
+async function $do93(client, request, options) {
   const parsed = safeParse(request, (value) => GetWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59584,12 +60373,12 @@ var init_webhooksGet = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksGet.ts
-var args90, tool$webhooksGet;
+var args93, tool$webhooksGet;
 var init_webhooksGet2 = __esm(() => {
   init_webhooksGet();
   init_operations();
   init_tools();
-  args90 = {
+  args93 = {
     request: GetWebhookRequest$inboundSchema
   };
   tool$webhooksGet = {
@@ -59597,9 +60386,9 @@ var init_webhooksGet2 = __esm(() => {
     description: `Get a webhook
 
 Retrieve a single webhook object by its ID.`,
-    args: args90,
-    tool: async (client, args91, ctx) => {
-      const [result, apiCall] = await webhooksGet(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args93,
+    tool: async (client, args94, ctx) => {
+      const [result, apiCall] = await webhooksGet(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59614,9 +60403,9 @@ Retrieve a single webhook object by its ID.`,
 
 // src/funcs/webhooksList.ts
 function webhooksList(client, request, options) {
-  return new APIPromise($do91(client, request, options));
+  return new APIPromise($do94(client, request, options));
 }
-async function $do91(client, request, options) {
+async function $do94(client, request, options) {
   const parsed = safeParse(request, (value) => ListWebhooksRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59707,12 +60496,12 @@ var init_webhooksList = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksList.ts
-var args91, tool$webhooksList;
+var args94, tool$webhooksList;
 var init_webhooksList2 = __esm(() => {
   init_webhooksList();
   init_operations();
   init_tools();
-  args91 = {
+  args94 = {
     request: ListWebhooksRequest$inboundSchema.optional()
   };
   tool$webhooksList = {
@@ -59720,9 +60509,9 @@ var init_webhooksList2 = __esm(() => {
     description: `List all webhooks
 
 Returns a paginated list of your webhooks. If no webhook endpoints are available, the resulting array will be empty. This request should never throw an error.`,
-    args: args91,
-    tool: async (client, args92, ctx) => {
-      const [result, apiCall] = await webhooksList(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args94,
+    tool: async (client, args95, ctx) => {
+      const [result, apiCall] = await webhooksList(client, args95.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59737,9 +60526,9 @@ Returns a paginated list of your webhooks. If no webhook endpoints are available
 
 // src/funcs/webhooksTest.ts
 function webhooksTest(client, request, options) {
-  return new APIPromise($do92(client, request, options));
+  return new APIPromise($do95(client, request, options));
 }
-async function $do92(client, request, options) {
+async function $do95(client, request, options) {
   const parsed = safeParse(request, (value) => TestWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59828,12 +60617,12 @@ var init_webhooksTest = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksTest.ts
-var args92, tool$webhooksTest;
+var args95, tool$webhooksTest;
 var init_webhooksTest2 = __esm(() => {
   init_webhooksTest();
   init_operations();
   init_tools();
-  args92 = {
+  args95 = {
     request: TestWebhookRequest$inboundSchema
   };
   tool$webhooksTest = {
@@ -59841,9 +60630,9 @@ var init_webhooksTest2 = __esm(() => {
     description: `Test a webhook
 
 Sends a test event to the webhook to verify the endpoint is working as expected.`,
-    args: args92,
-    tool: async (client, args93, ctx) => {
-      const [result, apiCall] = await webhooksTest(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args95,
+    tool: async (client, args96, ctx) => {
+      const [result, apiCall] = await webhooksTest(client, args96.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59858,9 +60647,9 @@ Sends a test event to the webhook to verify the endpoint is working as expected.
 
 // src/funcs/webhooksUpdate.ts
 function webhooksUpdate(client, request, options) {
-  return new APIPromise($do93(client, request, options));
+  return new APIPromise($do96(client, request, options));
 }
-async function $do93(client, request, options) {
+async function $do96(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateWebhookRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -59951,12 +60740,12 @@ var init_webhooksUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/webhooksUpdate.ts
-var args93, tool$webhooksUpdate;
+var args96, tool$webhooksUpdate;
 var init_webhooksUpdate2 = __esm(() => {
   init_webhooksUpdate();
   init_operations();
   init_tools();
-  args93 = {
+  args96 = {
     request: UpdateWebhookRequest$inboundSchema
   };
   tool$webhooksUpdate = {
@@ -59964,9 +60753,9 @@ var init_webhooksUpdate2 = __esm(() => {
     description: `Update a webhook
 
 Updates the webhook. You may edit the name, url and the list of subscribed event types.`,
-    args: args93,
-    tool: async (client, args94, ctx) => {
-      const [result, apiCall] = await webhooksUpdate(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args96,
+    tool: async (client, args97, ctx) => {
+      const [result, apiCall] = await webhooksUpdate(client, args97.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -59983,7 +60772,7 @@ Updates the webhook. You may edit the name, url and the list of subscribed event
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Client",
-    version: "0.2.9"
+    version: "0.3.0"
   });
   const client = new ClientCore({
     security: deps.security,
@@ -60036,6 +60825,9 @@ function createMCPServer(deps) {
   tool(tool$webhooksDelete);
   tool(tool$webhooksTest);
   tool(tool$webhookEventsGet);
+  tool(tool$balanceTransfersCreate);
+  tool(tool$balanceTransfersList);
+  tool(tool$balanceTransfersGet);
   tool(tool$paymentsCreate);
   tool(tool$paymentsList);
   tool(tool$paymentsGet);
@@ -60102,6 +60894,9 @@ var init_server2 = __esm(() => {
   init_balancesGetReport2();
   init_balancesList2();
   init_balancesListTransactions2();
+  init_balanceTransfersCreate2();
+  init_balanceTransfersGet2();
+  init_balanceTransfersList2();
   init_capabilitiesList2();
   init_capturesCreate2();
   init_capturesGet2();
@@ -61372,7 +62167,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.2.9"
+    currentVersion: "0.3.0"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -61380,5 +62175,5 @@ export {
   app
 };
 
-//# debugId=854CE418D53E4D7764756E2164756E21
+//# debugId=73678A33F322389864756E2164756E21
 //# sourceMappingURL=mcp-server.js.map