@gr4vy/sdk 0.18.13 → 0.18.15

package/bin/mcp-server.js

@@ -4020,15 +4020,15 @@ var ServerProduction = "production", ServerSandbox = "sandbox", ServerList, SDK_
 var init_config = __esm(() => {
   init_url();
   ServerList = {
-    [ServerProduction]: "https://api.{id}.gr4vy.app",
+    [ServerProduction]: "https://api.example.gr4vy.app",
     [ServerSandbox]: "https://api.sandbox.{id}.gr4vy.app"
   };
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.18.13",
-    genVersion: "2.593.3",
-    userAgent: "speakeasy-sdk/typescript 0.18.13 2.593.3 1.0.0 @gr4vy/sdk"
+    sdkVersion: "0.18.15",
+    genVersion: "2.593.4",
+    userAgent: "speakeasy-sdk/typescript 0.18.15 2.593.4 1.0.0 @gr4vy/sdk"
   };
 });
 
@@ -37799,6 +37799,154 @@ var init_collectiongiftcard = __esm(() => {
   })(CollectionGiftCard$ ||= {});
 });
 
+// src/models/components/merchantaccount.ts
+var MerchantAccount$inboundSchema, MerchantAccount$outboundSchema, MerchantAccount$;
+var init_merchantaccount = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_cardscheme();
+  MerchantAccount$inboundSchema = objectType({
+    type: literalType("merchant-account").default("merchant-account"),
+    id: stringType(),
+    display_name: stringType(),
+    outbound_webhook_url: nullableType(stringType()).optional(),
+    outbound_webhook_username: nullableType(stringType()).optional(),
+    outbound_webhook_password: nullableType(stringType()).optional(),
+    loon_client_key: nullableType(stringType()).optional(),
+    loon_secret_key: nullableType(stringType()).optional(),
+    loon_accepted_schemes: nullableType(arrayType(CardScheme$inboundSchema)).optional(),
+    account_updater_request_encryption_key: nullableType(stringType()).optional(),
+    account_updater_request_encryption_key_id: nullableType(stringType()).optional(),
+    account_updater_response_decryption_key: nullableType(stringType()).optional(),
+    account_updater_response_decryption_key_id: nullableType(stringType()).optional(),
+    account_updater_enabled: booleanType(),
+    over_capture_amount: nullableType(numberType().int()).optional(),
+    over_capture_percentage: nullableType(numberType().int()).optional(),
+    visa_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    visa_network_tokens_app_id: nullableType(stringType()).optional(),
+    amex_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    amex_network_tokens_app_id: nullableType(stringType()).optional(),
+    mastercard_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    mastercard_network_tokens_app_id: nullableType(stringType()).optional(),
+    created_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)),
+    updated_at: stringType().datetime({ offset: true }).transform((v2) => new Date(v2))
+  }).transform((v2) => {
+    return remap(v2, {
+      display_name: "displayName",
+      outbound_webhook_url: "outboundWebhookUrl",
+      outbound_webhook_username: "outboundWebhookUsername",
+      outbound_webhook_password: "outboundWebhookPassword",
+      loon_client_key: "loonClientKey",
+      loon_secret_key: "loonSecretKey",
+      loon_accepted_schemes: "loonAcceptedSchemes",
+      account_updater_request_encryption_key: "accountUpdaterRequestEncryptionKey",
+      account_updater_request_encryption_key_id: "accountUpdaterRequestEncryptionKeyId",
+      account_updater_response_decryption_key: "accountUpdaterResponseDecryptionKey",
+      account_updater_response_decryption_key_id: "accountUpdaterResponseDecryptionKeyId",
+      account_updater_enabled: "accountUpdaterEnabled",
+      over_capture_amount: "overCaptureAmount",
+      over_capture_percentage: "overCapturePercentage",
+      visa_network_tokens_requestor_id: "visaNetworkTokensRequestorId",
+      visa_network_tokens_app_id: "visaNetworkTokensAppId",
+      amex_network_tokens_requestor_id: "amexNetworkTokensRequestorId",
+      amex_network_tokens_app_id: "amexNetworkTokensAppId",
+      mastercard_network_tokens_requestor_id: "mastercardNetworkTokensRequestorId",
+      mastercard_network_tokens_app_id: "mastercardNetworkTokensAppId",
+      created_at: "createdAt",
+      updated_at: "updatedAt"
+    });
+  });
+  MerchantAccount$outboundSchema = objectType({
+    type: literalType("merchant-account").default("merchant-account"),
+    id: stringType(),
+    displayName: stringType(),
+    outboundWebhookUrl: nullableType(stringType()).optional(),
+    outboundWebhookUsername: nullableType(stringType()).optional(),
+    outboundWebhookPassword: nullableType(stringType()).optional(),
+    loonClientKey: nullableType(stringType()).optional(),
+    loonSecretKey: nullableType(stringType()).optional(),
+    loonAcceptedSchemes: nullableType(arrayType(CardScheme$outboundSchema)).optional(),
+    accountUpdaterRequestEncryptionKey: nullableType(stringType()).optional(),
+    accountUpdaterRequestEncryptionKeyId: nullableType(stringType()).optional(),
+    accountUpdaterResponseDecryptionKey: nullableType(stringType()).optional(),
+    accountUpdaterResponseDecryptionKeyId: nullableType(stringType()).optional(),
+    accountUpdaterEnabled: booleanType(),
+    overCaptureAmount: nullableType(numberType().int()).optional(),
+    overCapturePercentage: nullableType(numberType().int()).optional(),
+    visaNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    visaNetworkTokensAppId: nullableType(stringType()).optional(),
+    amexNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    amexNetworkTokensAppId: nullableType(stringType()).optional(),
+    mastercardNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    mastercardNetworkTokensAppId: nullableType(stringType()).optional(),
+    createdAt: dateType().transform((v2) => v2.toISOString()),
+    updatedAt: dateType().transform((v2) => v2.toISOString())
+  }).transform((v2) => {
+    return remap(v2, {
+      displayName: "display_name",
+      outboundWebhookUrl: "outbound_webhook_url",
+      outboundWebhookUsername: "outbound_webhook_username",
+      outboundWebhookPassword: "outbound_webhook_password",
+      loonClientKey: "loon_client_key",
+      loonSecretKey: "loon_secret_key",
+      loonAcceptedSchemes: "loon_accepted_schemes",
+      accountUpdaterRequestEncryptionKey: "account_updater_request_encryption_key",
+      accountUpdaterRequestEncryptionKeyId: "account_updater_request_encryption_key_id",
+      accountUpdaterResponseDecryptionKey: "account_updater_response_decryption_key",
+      accountUpdaterResponseDecryptionKeyId: "account_updater_response_decryption_key_id",
+      accountUpdaterEnabled: "account_updater_enabled",
+      overCaptureAmount: "over_capture_amount",
+      overCapturePercentage: "over_capture_percentage",
+      visaNetworkTokensRequestorId: "visa_network_tokens_requestor_id",
+      visaNetworkTokensAppId: "visa_network_tokens_app_id",
+      amexNetworkTokensRequestorId: "amex_network_tokens_requestor_id",
+      amexNetworkTokensAppId: "amex_network_tokens_app_id",
+      mastercardNetworkTokensRequestorId: "mastercard_network_tokens_requestor_id",
+      mastercardNetworkTokensAppId: "mastercard_network_tokens_app_id",
+      createdAt: "created_at",
+      updatedAt: "updated_at"
+    });
+  });
+  ((MerchantAccount$) => {
+    MerchantAccount$.inboundSchema = MerchantAccount$inboundSchema;
+    MerchantAccount$.outboundSchema = MerchantAccount$outboundSchema;
+  })(MerchantAccount$ ||= {});
+});
+
+// src/models/components/collectionmerchantaccount.ts
+var CollectionMerchantAccount$inboundSchema, CollectionMerchantAccount$outboundSchema, CollectionMerchantAccount$;
+var init_collectionmerchantaccount = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_merchantaccount();
+  CollectionMerchantAccount$inboundSchema = objectType({
+    items: arrayType(MerchantAccount$inboundSchema),
+    limit: numberType().int().default(20),
+    next_cursor: nullableType(stringType()).optional(),
+    previous_cursor: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      next_cursor: "nextCursor",
+      previous_cursor: "previousCursor"
+    });
+  });
+  CollectionMerchantAccount$outboundSchema = objectType({
+    items: arrayType(MerchantAccount$outboundSchema),
+    limit: numberType().int().default(20),
+    nextCursor: nullableType(stringType()).optional(),
+    previousCursor: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      nextCursor: "next_cursor",
+      previousCursor: "previous_cursor"
+    });
+  });
+  ((CollectionMerchantAccount$) => {
+    CollectionMerchantAccount$.inboundSchema = CollectionMerchantAccount$inboundSchema;
+    CollectionMerchantAccount$.outboundSchema = CollectionMerchantAccount$outboundSchema;
+  })(CollectionMerchantAccount$ ||= {});
+});
+
 // src/models/components/collectionnocursorcardschemedefinition.ts
 var CollectionNoCursorCardSchemeDefinition$inboundSchema, CollectionNoCursorCardSchemeDefinition$outboundSchema, CollectionNoCursorCardSchemeDefinition$;
 var init_collectionnocursorcardschemedefinition = __esm(() => {
@@ -40452,6 +40600,212 @@ var init_googlepaysessionrequest = __esm(() => {
   })(GooglePaySessionRequest$ ||= {});
 });
 
+// src/models/components/merchantaccountcreate.ts
+var MerchantAccountCreate$inboundSchema, MerchantAccountCreate$outboundSchema, MerchantAccountCreate$;
+var init_merchantaccountcreate = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_cardscheme();
+  MerchantAccountCreate$inboundSchema = objectType({
+    account_updater_enabled: booleanType().default(false),
+    account_updater_request_encryption_key: nullableType(stringType()).optional(),
+    account_updater_request_encryption_key_id: nullableType(stringType()).optional(),
+    account_updater_response_decryption_key: nullableType(stringType()).optional(),
+    account_updater_response_decryption_key_id: nullableType(stringType()).optional(),
+    over_capture_amount: nullableType(numberType().int()).optional(),
+    over_capture_percentage: nullableType(numberType().int()).optional(),
+    loon_client_key: nullableType(stringType()).optional(),
+    loon_secret_key: nullableType(stringType()).optional(),
+    loon_accepted_schemes: nullableType(arrayType(CardScheme$inboundSchema)).optional(),
+    visa_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    visa_network_tokens_app_id: nullableType(stringType()).optional(),
+    amex_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    amex_network_tokens_app_id: nullableType(stringType()).optional(),
+    mastercard_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    mastercard_network_tokens_app_id: nullableType(stringType()).optional(),
+    outbound_webhook_url: nullableType(stringType()).optional(),
+    outbound_webhook_username: nullableType(stringType()).optional(),
+    outbound_webhook_password: nullableType(stringType()).optional(),
+    id: stringType(),
+    display_name: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      account_updater_enabled: "accountUpdaterEnabled",
+      account_updater_request_encryption_key: "accountUpdaterRequestEncryptionKey",
+      account_updater_request_encryption_key_id: "accountUpdaterRequestEncryptionKeyId",
+      account_updater_response_decryption_key: "accountUpdaterResponseDecryptionKey",
+      account_updater_response_decryption_key_id: "accountUpdaterResponseDecryptionKeyId",
+      over_capture_amount: "overCaptureAmount",
+      over_capture_percentage: "overCapturePercentage",
+      loon_client_key: "loonClientKey",
+      loon_secret_key: "loonSecretKey",
+      loon_accepted_schemes: "loonAcceptedSchemes",
+      visa_network_tokens_requestor_id: "visaNetworkTokensRequestorId",
+      visa_network_tokens_app_id: "visaNetworkTokensAppId",
+      amex_network_tokens_requestor_id: "amexNetworkTokensRequestorId",
+      amex_network_tokens_app_id: "amexNetworkTokensAppId",
+      mastercard_network_tokens_requestor_id: "mastercardNetworkTokensRequestorId",
+      mastercard_network_tokens_app_id: "mastercardNetworkTokensAppId",
+      outbound_webhook_url: "outboundWebhookUrl",
+      outbound_webhook_username: "outboundWebhookUsername",
+      outbound_webhook_password: "outboundWebhookPassword",
+      display_name: "displayName"
+    });
+  });
+  MerchantAccountCreate$outboundSchema = objectType({
+    accountUpdaterEnabled: booleanType().default(false),
+    accountUpdaterRequestEncryptionKey: nullableType(stringType()).optional(),
+    accountUpdaterRequestEncryptionKeyId: nullableType(stringType()).optional(),
+    accountUpdaterResponseDecryptionKey: nullableType(stringType()).optional(),
+    accountUpdaterResponseDecryptionKeyId: nullableType(stringType()).optional(),
+    overCaptureAmount: nullableType(numberType().int()).optional(),
+    overCapturePercentage: nullableType(numberType().int()).optional(),
+    loonClientKey: nullableType(stringType()).optional(),
+    loonSecretKey: nullableType(stringType()).optional(),
+    loonAcceptedSchemes: nullableType(arrayType(CardScheme$outboundSchema)).optional(),
+    visaNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    visaNetworkTokensAppId: nullableType(stringType()).optional(),
+    amexNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    amexNetworkTokensAppId: nullableType(stringType()).optional(),
+    mastercardNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    mastercardNetworkTokensAppId: nullableType(stringType()).optional(),
+    outboundWebhookUrl: nullableType(stringType()).optional(),
+    outboundWebhookUsername: nullableType(stringType()).optional(),
+    outboundWebhookPassword: nullableType(stringType()).optional(),
+    id: stringType(),
+    displayName: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      accountUpdaterEnabled: "account_updater_enabled",
+      accountUpdaterRequestEncryptionKey: "account_updater_request_encryption_key",
+      accountUpdaterRequestEncryptionKeyId: "account_updater_request_encryption_key_id",
+      accountUpdaterResponseDecryptionKey: "account_updater_response_decryption_key",
+      accountUpdaterResponseDecryptionKeyId: "account_updater_response_decryption_key_id",
+      overCaptureAmount: "over_capture_amount",
+      overCapturePercentage: "over_capture_percentage",
+      loonClientKey: "loon_client_key",
+      loonSecretKey: "loon_secret_key",
+      loonAcceptedSchemes: "loon_accepted_schemes",
+      visaNetworkTokensRequestorId: "visa_network_tokens_requestor_id",
+      visaNetworkTokensAppId: "visa_network_tokens_app_id",
+      amexNetworkTokensRequestorId: "amex_network_tokens_requestor_id",
+      amexNetworkTokensAppId: "amex_network_tokens_app_id",
+      mastercardNetworkTokensRequestorId: "mastercard_network_tokens_requestor_id",
+      mastercardNetworkTokensAppId: "mastercard_network_tokens_app_id",
+      outboundWebhookUrl: "outbound_webhook_url",
+      outboundWebhookUsername: "outbound_webhook_username",
+      outboundWebhookPassword: "outbound_webhook_password",
+      displayName: "display_name"
+    });
+  });
+  ((MerchantAccountCreate$) => {
+    MerchantAccountCreate$.inboundSchema = MerchantAccountCreate$inboundSchema;
+    MerchantAccountCreate$.outboundSchema = MerchantAccountCreate$outboundSchema;
+  })(MerchantAccountCreate$ ||= {});
+});
+
+// src/models/components/merchantaccountupdate.ts
+var MerchantAccountUpdate$inboundSchema, MerchantAccountUpdate$outboundSchema, MerchantAccountUpdate$;
+var init_merchantaccountupdate = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_cardscheme();
+  MerchantAccountUpdate$inboundSchema = objectType({
+    account_updater_enabled: booleanType().default(false),
+    account_updater_request_encryption_key: nullableType(stringType()).optional(),
+    account_updater_request_encryption_key_id: nullableType(stringType()).optional(),
+    account_updater_response_decryption_key: nullableType(stringType()).optional(),
+    account_updater_response_decryption_key_id: nullableType(stringType()).optional(),
+    over_capture_amount: nullableType(numberType().int()).optional(),
+    over_capture_percentage: nullableType(numberType().int()).optional(),
+    loon_client_key: nullableType(stringType()).optional(),
+    loon_secret_key: nullableType(stringType()).optional(),
+    loon_accepted_schemes: nullableType(arrayType(CardScheme$inboundSchema)).optional(),
+    visa_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    visa_network_tokens_app_id: nullableType(stringType()).optional(),
+    amex_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    amex_network_tokens_app_id: nullableType(stringType()).optional(),
+    mastercard_network_tokens_requestor_id: nullableType(stringType()).optional(),
+    mastercard_network_tokens_app_id: nullableType(stringType()).optional(),
+    display_name: nullableType(stringType()).optional(),
+    outbound_webhook_url: nullableType(stringType()).optional(),
+    outbound_webhook_username: nullableType(stringType()).optional(),
+    outbound_webhook_password: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      account_updater_enabled: "accountUpdaterEnabled",
+      account_updater_request_encryption_key: "accountUpdaterRequestEncryptionKey",
+      account_updater_request_encryption_key_id: "accountUpdaterRequestEncryptionKeyId",
+      account_updater_response_decryption_key: "accountUpdaterResponseDecryptionKey",
+      account_updater_response_decryption_key_id: "accountUpdaterResponseDecryptionKeyId",
+      over_capture_amount: "overCaptureAmount",
+      over_capture_percentage: "overCapturePercentage",
+      loon_client_key: "loonClientKey",
+      loon_secret_key: "loonSecretKey",
+      loon_accepted_schemes: "loonAcceptedSchemes",
+      visa_network_tokens_requestor_id: "visaNetworkTokensRequestorId",
+      visa_network_tokens_app_id: "visaNetworkTokensAppId",
+      amex_network_tokens_requestor_id: "amexNetworkTokensRequestorId",
+      amex_network_tokens_app_id: "amexNetworkTokensAppId",
+      mastercard_network_tokens_requestor_id: "mastercardNetworkTokensRequestorId",
+      mastercard_network_tokens_app_id: "mastercardNetworkTokensAppId",
+      display_name: "displayName",
+      outbound_webhook_url: "outboundWebhookUrl",
+      outbound_webhook_username: "outboundWebhookUsername",
+      outbound_webhook_password: "outboundWebhookPassword"
+    });
+  });
+  MerchantAccountUpdate$outboundSchema = objectType({
+    accountUpdaterEnabled: booleanType().default(false),
+    accountUpdaterRequestEncryptionKey: nullableType(stringType()).optional(),
+    accountUpdaterRequestEncryptionKeyId: nullableType(stringType()).optional(),
+    accountUpdaterResponseDecryptionKey: nullableType(stringType()).optional(),
+    accountUpdaterResponseDecryptionKeyId: nullableType(stringType()).optional(),
+    overCaptureAmount: nullableType(numberType().int()).optional(),
+    overCapturePercentage: nullableType(numberType().int()).optional(),
+    loonClientKey: nullableType(stringType()).optional(),
+    loonSecretKey: nullableType(stringType()).optional(),
+    loonAcceptedSchemes: nullableType(arrayType(CardScheme$outboundSchema)).optional(),
+    visaNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    visaNetworkTokensAppId: nullableType(stringType()).optional(),
+    amexNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    amexNetworkTokensAppId: nullableType(stringType()).optional(),
+    mastercardNetworkTokensRequestorId: nullableType(stringType()).optional(),
+    mastercardNetworkTokensAppId: nullableType(stringType()).optional(),
+    displayName: nullableType(stringType()).optional(),
+    outboundWebhookUrl: nullableType(stringType()).optional(),
+    outboundWebhookUsername: nullableType(stringType()).optional(),
+    outboundWebhookPassword: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      accountUpdaterEnabled: "account_updater_enabled",
+      accountUpdaterRequestEncryptionKey: "account_updater_request_encryption_key",
+      accountUpdaterRequestEncryptionKeyId: "account_updater_request_encryption_key_id",
+      accountUpdaterResponseDecryptionKey: "account_updater_response_decryption_key",
+      accountUpdaterResponseDecryptionKeyId: "account_updater_response_decryption_key_id",
+      overCaptureAmount: "over_capture_amount",
+      overCapturePercentage: "over_capture_percentage",
+      loonClientKey: "loon_client_key",
+      loonSecretKey: "loon_secret_key",
+      loonAcceptedSchemes: "loon_accepted_schemes",
+      visaNetworkTokensRequestorId: "visa_network_tokens_requestor_id",
+      visaNetworkTokensAppId: "visa_network_tokens_app_id",
+      amexNetworkTokensRequestorId: "amex_network_tokens_requestor_id",
+      amexNetworkTokensAppId: "amex_network_tokens_app_id",
+      mastercardNetworkTokensRequestorId: "mastercard_network_tokens_requestor_id",
+      mastercardNetworkTokensAppId: "mastercard_network_tokens_app_id",
+      displayName: "display_name",
+      outboundWebhookUrl: "outbound_webhook_url",
+      outboundWebhookUsername: "outbound_webhook_username",
+      outboundWebhookPassword: "outbound_webhook_password"
+    });
+  });
+  ((MerchantAccountUpdate$) => {
+    MerchantAccountUpdate$.inboundSchema = MerchantAccountUpdate$inboundSchema;
+    MerchantAccountUpdate$.outboundSchema = MerchantAccountUpdate$outboundSchema;
+  })(MerchantAccountUpdate$ ||= {});
+});
+
 // src/models/components/networktokencreate.ts
 var NetworkTokenCreate$inboundSchema, NetworkTokenCreate$outboundSchema, NetworkTokenCreate$;
 var init_networktokencreate = __esm(() => {
@@ -42055,6 +42409,7 @@ var init_components = __esm(() => {
   init_collectionauditlogentry();
   init_collectionbuyer();
   init_collectiongiftcard();
+  init_collectionmerchantaccount();
   init_collectionnocursorcardschemedefinition();
   init_collectionnocursordigitalwallet();
   init_collectionnocursorgiftcardsummary();
@@ -42102,6 +42457,9 @@ var init_components = __esm(() => {
   init_guestbuyerinput();
   init_guestbuyeroutput();
   init_instrumenttype();
+  init_merchantaccount();
+  init_merchantaccountcreate();
+  init_merchantaccountupdate();
   init_method();
   init_mode();
   init_networktoken();
@@ -42565,6 +42923,29 @@ var init_creategooglepaydigitalwalletsession = __esm(() => {
   })(CreateGooglePayDigitalWalletSessionResponse403CreateGooglePayDigitalWalletSession$ ||= {});
 });
 
+// src/models/errors/createmerchantaccount.ts
+var CreateMerchantAccountResponse403CreateMerchantAccount$inboundSchema, CreateMerchantAccountResponse403CreateMerchantAccount$outboundSchema, CreateMerchantAccountResponse403CreateMerchantAccount$;
+var init_createmerchantaccount = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  CreateMerchantAccountResponse403CreateMerchantAccount$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  CreateMerchantAccountResponse403CreateMerchantAccount$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((CreateMerchantAccountResponse403CreateMerchantAccount$) => {
+    CreateMerchantAccountResponse403CreateMerchantAccount$.inboundSchema = CreateMerchantAccountResponse403CreateMerchantAccount$inboundSchema;
+    CreateMerchantAccountResponse403CreateMerchantAccount$.outboundSchema = CreateMerchantAccountResponse403CreateMerchantAccount$outboundSchema;
+  })(CreateMerchantAccountResponse403CreateMerchantAccount$ ||= {});
+});
+
 // src/models/errors/createpaymentmethod.ts
 var CreatePaymentMethodResponse403CreatePaymentMethod$inboundSchema, CreatePaymentMethodResponse403CreatePaymentMethod$outboundSchema, CreatePaymentMethodResponse403CreatePaymentMethod$;
 var init_createpaymentmethod = __esm(() => {
@@ -43505,6 +43886,29 @@ var init_getgiftcard = __esm(() => {
   })(GetGiftCardResponse403GetGiftCard$ ||= {});
 });
 
+// src/models/errors/getmerchantaccount.ts
+var GetMerchantAccountResponse403GetMerchantAccount$inboundSchema, GetMerchantAccountResponse403GetMerchantAccount$outboundSchema, GetMerchantAccountResponse403GetMerchantAccount$;
+var init_getmerchantaccount = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  GetMerchantAccountResponse403GetMerchantAccount$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  GetMerchantAccountResponse403GetMerchantAccount$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((GetMerchantAccountResponse403GetMerchantAccount$) => {
+    GetMerchantAccountResponse403GetMerchantAccount$.inboundSchema = GetMerchantAccountResponse403GetMerchantAccount$inboundSchema;
+    GetMerchantAccountResponse403GetMerchantAccount$.outboundSchema = GetMerchantAccountResponse403GetMerchantAccount$outboundSchema;
+  })(GetMerchantAccountResponse403GetMerchantAccount$ ||= {});
+});
+
 // src/models/errors/getpaymentmethod.ts
 var GetPaymentMethodResponse403GetPaymentMethod$inboundSchema, GetPaymentMethodResponse403GetPaymentMethod$outboundSchema, GetPaymentMethodResponse403GetPaymentMethod$;
 var init_getpaymentmethod = __esm(() => {
@@ -43881,6 +44285,29 @@ var init_listgiftcards = __esm(() => {
   })(ListGiftCardsResponse403ListGiftCards$ ||= {});
 });
 
+// src/models/errors/listmerchantaccounts.ts
+var ListMerchantAccountsResponse403ListMerchantAccounts$inboundSchema, ListMerchantAccountsResponse403ListMerchantAccounts$outboundSchema, ListMerchantAccountsResponse403ListMerchantAccounts$;
+var init_listmerchantaccounts = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  ListMerchantAccountsResponse403ListMerchantAccounts$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  ListMerchantAccountsResponse403ListMerchantAccounts$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((ListMerchantAccountsResponse403ListMerchantAccounts$) => {
+    ListMerchantAccountsResponse403ListMerchantAccounts$.inboundSchema = ListMerchantAccountsResponse403ListMerchantAccounts$inboundSchema;
+    ListMerchantAccountsResponse403ListMerchantAccounts$.outboundSchema = ListMerchantAccountsResponse403ListMerchantAccounts$outboundSchema;
+  })(ListMerchantAccountsResponse403ListMerchantAccounts$ ||= {});
+});
+
 // src/models/errors/listpaymentmethodnetworktokens.ts
 var ListPaymentMethodNetworkTokensResponse403ListPaymentMethodNetworkTokens$inboundSchema, ListPaymentMethodNetworkTokensResponse403ListPaymentMethodNetworkTokens$outboundSchema, ListPaymentMethodNetworkTokensResponse403ListPaymentMethodNetworkTokens$;
 var init_listpaymentmethodnetworktokens = __esm(() => {
@@ -44249,6 +44676,29 @@ var init_updatedigitalwallet = __esm(() => {
   })(UpdateDigitalWalletResponse403UpdateDigitalWallet$ ||= {});
 });
 
+// src/models/errors/updatemerchantaccount.ts
+var UpdateMerchantAccountResponse403UpdateMerchantAccount$inboundSchema, UpdateMerchantAccountResponse403UpdateMerchantAccount$outboundSchema, UpdateMerchantAccountResponse403UpdateMerchantAccount$;
+var init_updatemerchantaccount = __esm(() => {
+  init_lib();
+  init_error403();
+  init_error403active();
+  init_error403forbidden();
+  UpdateMerchantAccountResponse403UpdateMerchantAccount$inboundSchema = unionType([
+    Error403$inboundSchema,
+    Error403Forbidden$inboundSchema,
+    Error403Active$inboundSchema
+  ]);
+  UpdateMerchantAccountResponse403UpdateMerchantAccount$outboundSchema = unionType([
+    Error403$outboundSchema,
+    Error403Forbidden$outboundSchema,
+    Error403Active$outboundSchema
+  ]);
+  ((UpdateMerchantAccountResponse403UpdateMerchantAccount$) => {
+    UpdateMerchantAccountResponse403UpdateMerchantAccount$.inboundSchema = UpdateMerchantAccountResponse403UpdateMerchantAccount$inboundSchema;
+    UpdateMerchantAccountResponse403UpdateMerchantAccount$.outboundSchema = UpdateMerchantAccountResponse403UpdateMerchantAccount$outboundSchema;
+  })(UpdateMerchantAccountResponse403UpdateMerchantAccount$ ||= {});
+});
+
 // src/models/errors/voidtransaction.ts
 var VoidTransactionResponse403VoidTransaction$inboundSchema, VoidTransactionResponse403VoidTransaction$outboundSchema, VoidTransactionResponse403VoidTransaction$;
 var init_voidtransaction = __esm(() => {
@@ -44285,6 +44735,7 @@ var init_errors = __esm(() => {
   init_createfulltransactionrefund();
   init_creategiftcard();
   init_creategooglepaydigitalwalletsession();
+  init_createmerchantaccount();
   init_createpaymentmethod();
   init_createpaymentmethodnetworktoken();
   init_createpaymentmethodnetworktokencryptogram();
@@ -44318,6 +44769,7 @@ var init_errors = __esm(() => {
   init_getcheckoutsession();
   init_getdigitalwallet();
   init_getgiftcard();
+  init_getmerchantaccount();
   init_getpaymentmethod();
   init_getpayout();
   init_getrefund();
@@ -44335,6 +44787,7 @@ var init_errors = __esm(() => {
   init_listdigitalwallets();
   init_listgiftcardbalances();
   init_listgiftcards();
+  init_listmerchantaccounts();
   init_listpaymentmethodnetworktokens();
   init_listpaymentmethodpaymentservicetokens();
   init_listpaymentmethods();
@@ -44353,6 +44806,7 @@ var init_errors = __esm(() => {
   init_updatebuyershippingdetails();
   init_updatecheckoutsession();
   init_updatedigitalwallet();
+  init_updatemerchantaccount();
   init_voidtransaction();
 });
 
@@ -44798,6 +45252,36 @@ var init_creategooglepaydigitalwalletsession2 = __esm(() => {
   })(CreateGooglePayDigitalWalletSessionRequest$ ||= {});
 });
 
+// src/models/operations/createmerchantaccount.ts
+var CreateMerchantAccountRequest$inboundSchema, CreateMerchantAccountRequest$outboundSchema, CreateMerchantAccountRequest$;
+var init_createmerchantaccount2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  CreateMerchantAccountRequest$inboundSchema = objectType({
+    timeout_in_seconds: numberType().default(1),
+    MerchantAccountCreate: MerchantAccountCreate$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      timeout_in_seconds: "timeoutInSeconds",
+      MerchantAccountCreate: "merchantAccountCreate"
+    });
+  });
+  CreateMerchantAccountRequest$outboundSchema = objectType({
+    timeoutInSeconds: numberType().default(1),
+    merchantAccountCreate: MerchantAccountCreate$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      timeoutInSeconds: "timeout_in_seconds",
+      merchantAccountCreate: "MerchantAccountCreate"
+    });
+  });
+  ((CreateMerchantAccountRequest$) => {
+    CreateMerchantAccountRequest$.inboundSchema = CreateMerchantAccountRequest$inboundSchema;
+    CreateMerchantAccountRequest$.outboundSchema = CreateMerchantAccountRequest$outboundSchema;
+  })(CreateMerchantAccountRequest$ ||= {});
+});
+
 // src/models/operations/createpaymentmethod.ts
 var CreatePaymentMethodGlobals$inboundSchema, CreatePaymentMethodGlobals$outboundSchema, CreatePaymentMethodGlobals$, CreatePaymentMethodBody$inboundSchema, CreatePaymentMethodBody$outboundSchema, CreatePaymentMethodBody$, CreatePaymentMethodRequest$inboundSchema, CreatePaymentMethodRequest$outboundSchema, CreatePaymentMethodRequest$;
 var init_createpaymentmethod2 = __esm(() => {
@@ -45673,6 +46157,31 @@ var init_getgiftcard2 = __esm(() => {
   })(GetGiftCardRequest$ ||= {});
 });
 
+// src/models/operations/getmerchantaccount.ts
+var GetMerchantAccountRequest$inboundSchema, GetMerchantAccountRequest$outboundSchema, GetMerchantAccountRequest$;
+var init_getmerchantaccount2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  GetMerchantAccountRequest$inboundSchema = objectType({
+    merchant_account_id: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      merchant_account_id: "merchantAccountId"
+    });
+  });
+  GetMerchantAccountRequest$outboundSchema = objectType({
+    merchantAccountId: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      merchantAccountId: "merchant_account_id"
+    });
+  });
+  ((GetMerchantAccountRequest$) => {
+    GetMerchantAccountRequest$.inboundSchema = GetMerchantAccountRequest$inboundSchema;
+    GetMerchantAccountRequest$.outboundSchema = GetMerchantAccountRequest$outboundSchema;
+  })(GetMerchantAccountRequest$ ||= {});
+});
+
 // src/models/operations/getpaymentmethod.ts
 var GetPaymentMethodGlobals$inboundSchema, GetPaymentMethodGlobals$outboundSchema, GetPaymentMethodGlobals$, GetPaymentMethodRequest$inboundSchema, GetPaymentMethodRequest$outboundSchema, GetPaymentMethodRequest$;
 var init_getpaymentmethod2 = __esm(() => {
@@ -46336,6 +46845,46 @@ var init_listgiftcards2 = __esm(() => {
   })(ListGiftCardsResponse$ ||= {});
 });
 
+// src/models/operations/listmerchantaccounts.ts
+var ListMerchantAccountsRequest$inboundSchema, ListMerchantAccountsRequest$outboundSchema, ListMerchantAccountsRequest$, ListMerchantAccountsResponse$inboundSchema, ListMerchantAccountsResponse$outboundSchema, ListMerchantAccountsResponse$;
+var init_listmerchantaccounts2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  ListMerchantAccountsRequest$inboundSchema = objectType({
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(20),
+    search: nullableType(stringType()).optional()
+  });
+  ListMerchantAccountsRequest$outboundSchema = objectType({
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(20),
+    search: nullableType(stringType()).optional()
+  });
+  ((ListMerchantAccountsRequest$) => {
+    ListMerchantAccountsRequest$.inboundSchema = ListMerchantAccountsRequest$inboundSchema;
+    ListMerchantAccountsRequest$.outboundSchema = ListMerchantAccountsRequest$outboundSchema;
+  })(ListMerchantAccountsRequest$ ||= {});
+  ListMerchantAccountsResponse$inboundSchema = objectType({
+    Result: CollectionMerchantAccount$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      Result: "result"
+    });
+  });
+  ListMerchantAccountsResponse$outboundSchema = objectType({
+    result: CollectionMerchantAccount$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      result: "Result"
+    });
+  });
+  ((ListMerchantAccountsResponse$) => {
+    ListMerchantAccountsResponse$.inboundSchema = ListMerchantAccountsResponse$inboundSchema;
+    ListMerchantAccountsResponse$.outboundSchema = ListMerchantAccountsResponse$outboundSchema;
+  })(ListMerchantAccountsResponse$ ||= {});
+});
+
 // src/models/operations/listpaymentmethodnetworktokens.ts
 var ListPaymentMethodNetworkTokensGlobals$inboundSchema, ListPaymentMethodNetworkTokensGlobals$outboundSchema, ListPaymentMethodNetworkTokensGlobals$, ListPaymentMethodNetworkTokensRequest$inboundSchema, ListPaymentMethodNetworkTokensRequest$outboundSchema, ListPaymentMethodNetworkTokensRequest$;
 var init_listpaymentmethodnetworktokens2 = __esm(() => {
@@ -47204,6 +47753,40 @@ var init_updatedigitalwallet2 = __esm(() => {
   })(UpdateDigitalWalletRequest$ ||= {});
 });
 
+// src/models/operations/updatemerchantaccount.ts
+var UpdateMerchantAccountRequest$inboundSchema, UpdateMerchantAccountRequest$outboundSchema, UpdateMerchantAccountRequest$;
+var init_updatemerchantaccount2 = __esm(() => {
+  init_lib();
+  init_primitives();
+  init_components();
+  UpdateMerchantAccountRequest$inboundSchema = objectType({
+    merchant_account_id: stringType(),
+    timeout_in_seconds: numberType().default(1),
+    MerchantAccountUpdate: MerchantAccountUpdate$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      merchant_account_id: "merchantAccountId",
+      timeout_in_seconds: "timeoutInSeconds",
+      MerchantAccountUpdate: "merchantAccountUpdate"
+    });
+  });
+  UpdateMerchantAccountRequest$outboundSchema = objectType({
+    merchantAccountId: stringType(),
+    timeoutInSeconds: numberType().default(1),
+    merchantAccountUpdate: MerchantAccountUpdate$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      merchantAccountId: "merchant_account_id",
+      timeoutInSeconds: "timeout_in_seconds",
+      merchantAccountUpdate: "MerchantAccountUpdate"
+    });
+  });
+  ((UpdateMerchantAccountRequest$) => {
+    UpdateMerchantAccountRequest$.inboundSchema = UpdateMerchantAccountRequest$inboundSchema;
+    UpdateMerchantAccountRequest$.outboundSchema = UpdateMerchantAccountRequest$outboundSchema;
+  })(UpdateMerchantAccountRequest$ ||= {});
+});
+
 // src/models/operations/voidtransaction.ts
 var VoidTransactionGlobals$inboundSchema, VoidTransactionGlobals$outboundSchema, VoidTransactionGlobals$, VoidTransactionRequest$inboundSchema, VoidTransactionRequest$outboundSchema, VoidTransactionRequest$;
 var init_voidtransaction2 = __esm(() => {
@@ -47257,6 +47840,7 @@ var init_operations = __esm(() => {
   init_createfulltransactionrefund2();
   init_creategiftcard2();
   init_creategooglepaydigitalwalletsession2();
+  init_createmerchantaccount2();
   init_createpaymentmethod2();
   init_createpaymentmethodnetworktoken2();
   init_createpaymentmethodnetworktokencryptogram2();
@@ -47277,6 +47861,7 @@ var init_operations = __esm(() => {
   init_getcheckoutsession2();
   init_getdigitalwallet2();
   init_getgiftcard2();
+  init_getmerchantaccount2();
   init_getpaymentmethod2();
   init_getpayout2();
   init_getrefund2();
@@ -47292,6 +47877,7 @@ var init_operations = __esm(() => {
   init_listdigitalwallets2();
   init_listgiftcardbalances2();
   init_listgiftcards2();
+  init_listmerchantaccounts2();
   init_listpaymentmethodnetworktokens2();
   init_listpaymentmethodpaymentservicetokens2();
   init_listpaymentmethods2();
@@ -47308,6 +47894,7 @@ var init_operations = __esm(() => {
   init_updatebuyershippingdetails2();
   init_updatecheckoutsession2();
   init_updatedigitalwallet2();
+  init_updatemerchantaccount2();
   init_voidtransaction2();
 });
 
@@ -51977,37 +52564,37 @@ Browser all gift cards.`,
   };
 });
 
-// src/funcs/paymentMethodsCreate.ts
-function paymentMethodsCreate(client, requestBody, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do35(client, requestBody, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/merchantAccountsCreate.ts
+function merchantAccountsCreate(client, merchantAccountCreate, timeoutInSeconds, options) {
+  return new APIPromise($do35(client, merchantAccountCreate, timeoutInSeconds, options));
 }
-async function $do35(client, requestBody, timeoutInSeconds, merchantAccountId, options) {
+async function $do35(client, merchantAccountCreate, timeoutInSeconds, options) {
   const input = {
-    requestBody,
-    timeoutInSeconds,
-    merchantAccountId
+    merchantAccountCreate,
+    timeoutInSeconds
   };
-  const parsed = safeParse(input, (value) => CreatePaymentMethodRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => CreateMerchantAccountRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.RequestBody, { explode: true });
-  const path = pathToFunc("/payment-methods")();
+  const body = encodeJSON("body", payload.MerchantAccountCreate, {
+    explode: true
+  });
+  const path = pathToFunc("/merchant-accounts")();
   const query = encodeFormQuery({
     timeout_in_seconds: payload.timeout_in_seconds
   });
   const headers = new Headers(compactMap({
     "Content-Type": "application/json",
-    Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+    Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create_payment_method",
+    operationID: "create_merchant_account",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -52056,13 +52643,13 @@ async function $do35(client, requestBody, timeoutInSeconds, merchantAccountId, o
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, PaymentMethod$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentMethodResponse403CreatePaymentMethod$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, MerchantAccount$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreateMerchantAccountResponse403CreateMerchantAccount$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsCreate = __esm(() => {
+var init_merchantAccountsCreate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -52075,26 +52662,25 @@ var init_paymentMethodsCreate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsCreate.ts
-var args35, tool$paymentMethodsCreate;
-var init_paymentMethodsCreate2 = __esm(() => {
+// src/mcp-server/tools/merchantAccountsCreate.ts
+var args35, tool$merchantAccountsCreate;
+var init_merchantAccountsCreate2 = __esm(() => {
   init_lib();
-  init_paymentMethodsCreate();
-  init_operations();
+  init_merchantAccountsCreate();
+  init_components();
   init_tools();
   args35 = {
-    requestBody: CreatePaymentMethodBody$inboundSchema,
-    timeoutInSeconds: numberType().default(1),
-    merchantAccountId: nullableType(stringType()).optional()
+    merchantAccountCreate: MerchantAccountCreate$inboundSchema,
+    timeoutInSeconds: numberType().default(1)
   };
-  tool$paymentMethodsCreate = {
-    name: "payment-methods-create",
-    description: `Create payment method
+  tool$merchantAccountsCreate = {
+    name: "merchant-accounts-create",
+    description: `Create a merchant account
 
-Store a new payment method.`,
+Create a new merchant account in an instance.`,
     args: args35,
     tool: async (client, args36, ctx) => {
-      const [result, apiCall] = await paymentMethodsCreate(client, args36.requestBody, args36.timeoutInSeconds, args36.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await merchantAccountsCreate(client, args36.merchantAccountCreate, args36.timeoutInSeconds, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52107,44 +52693,51 @@ Store a new payment method.`,
   };
 });
 
-// src/funcs/paymentMethodsDelete.ts
-function paymentMethodsDelete(client, paymentMethodId, merchantAccountId, options) {
-  return new APIPromise($do36(client, paymentMethodId, merchantAccountId, options));
+// src/funcs/merchantAccountsGet.ts
+function merchantAccountsGet(client, merchantAccountId, options) {
+  return new APIPromise($do36(client, merchantAccountId, options));
 }
-async function $do36(client, paymentMethodId, merchantAccountId, options) {
+async function $do36(client, merchantAccountId, options) {
   const input = {
-    paymentMethodId,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => DeletePaymentMethodRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => GetMerchantAccountRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
   const pathParams = {
-    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
+    merchant_account_id: encodeSimple("merchant_account_id", payload.merchant_account_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payment-methods/{payment_method_id}")(pathParams);
+  const path = pathToFunc("/merchant-accounts/{merchant_account_id}")(pathParams);
   const headers = new Headers(compactMap({
-    Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+    Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "delete_payment_method",
+    operationID: "get_merchant_account",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "DELETE",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -52183,83 +52776,85 @@ async function $do36(client, paymentMethodId, merchantAccountId, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, DeletePaymentMethodResponse403DeletePaymentMethod$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, MerchantAccount$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetMerchantAccountResponse403GetMerchantAccount$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsDelete = __esm(() => {
-  init_lib();
+var init_merchantAccountsGet = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
+  init_components();
   init_errors();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsDelete.ts
-var args36, tool$paymentMethodsDelete;
-var init_paymentMethodsDelete2 = __esm(() => {
+// src/mcp-server/tools/merchantAccountsGet.ts
+var args36, tool$merchantAccountsGet;
+var init_merchantAccountsGet2 = __esm(() => {
   init_lib();
-  init_paymentMethodsDelete();
+  init_merchantAccountsGet();
   init_tools();
   args36 = {
-    paymentMethodId: stringType(),
-    merchantAccountId: nullableType(stringType()).optional()
+    merchantAccountId: stringType()
   };
-  tool$paymentMethodsDelete = {
-    name: "payment-methods-delete",
-    description: `Delete payment method
+  tool$merchantAccountsGet = {
+    name: "merchant-accounts-get",
+    description: `Get a merchant account
 
-Delete a payment method.`,
+Get info about a merchant account in an instance.`,
     args: args36,
     tool: async (client, args37, ctx) => {
-      const [result, apiCall] = await paymentMethodsDelete(client, args37.paymentMethodId, args37.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await merchantAccountsGet(client, args37.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      return formatResult(undefined, apiCall);
+      const value = result.value;
+      return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/paymentMethodsGet.ts
-function paymentMethodsGet(client, paymentMethodId, merchantAccountId, options) {
-  return new APIPromise($do37(client, paymentMethodId, merchantAccountId, options));
+// src/funcs/merchantAccountsList.ts
+function merchantAccountsList(client, cursor, limit, search, options) {
+  return new APIPromise($do37(client, cursor, limit, search, options));
 }
-async function $do37(client, paymentMethodId, merchantAccountId, options) {
+async function $do37(client, cursor, limit, search, options) {
   const input = {
-    paymentMethodId,
-    merchantAccountId
+    cursor,
+    limit,
+    search
   };
-  const parsed = safeParse(input, (value) => GetPaymentMethodRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => ListMerchantAccountsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
+    return [haltIterator(parsed), { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
-  const pathParams = {
-    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
-  };
-  const path = pathToFunc("/payment-methods/{payment_method_id}")(pathParams);
+  const path = pathToFunc("/merchant-accounts")();
+  const query = encodeFormQuery({
+    cursor: payload?.cursor,
+    limit: payload?.limit,
+    search: payload?.search
+  });
   const headers = new Headers(compactMap({
-    Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+    Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "get_payment_method",
+    operationID: "list_merchant_accounts",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -52281,11 +52876,12 @@ async function $do37(client, paymentMethodId, merchantAccountId, options) {
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
   if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
+    return [haltIterator(requestRes), { status: "invalid" }];
   }
   const req = requestRes.value;
   const doResult = await client._do(req, {
@@ -52310,109 +52906,125 @@ async function $do37(client, paymentMethodId, merchantAccountId, options) {
     retryCodes: context.retryCodes
   });
   if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
+    return [haltIterator(doResult), { status: "request-error", request: req }];
   }
   const response = doResult.value;
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, PaymentMethod$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetPaymentMethodResponse403GetPaymentMethod$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result, raw] = await match(json(200, ListMerchantAccountsResponse$inboundSchema, {
+    key: "Result"
+  }), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListMerchantAccountsResponse403ListMerchantAccounts$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
-    return [result, { status: "complete", request: req, response }];
+    return [haltIterator(result), {
+      status: "complete",
+      request: req,
+      response
+    }];
   }
-  return [result, { status: "complete", request: req, response }];
+  const nextFunc = (responseData) => {
+    const nextCursor = dlv(responseData, "next_cursor");
+    if (typeof nextCursor !== "string") {
+      return { next: () => null };
+    }
+    const nextVal = () => merchantAccountsList(client, nextCursor, limit, search, options);
+    return { next: nextVal, "~next": { cursor: nextCursor } };
+  };
+  const page = { ...result, ...nextFunc(raw) };
+  return [{ ...page, ...createPageIterator(page, (v2) => !v2.ok) }, {
+    status: "complete",
+    request: req,
+    response
+  }];
 }
-var init_paymentMethodsGet = __esm(() => {
+var init_merchantAccountsList = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
-  init_components();
   init_errors();
   init_operations();
   init_async();
+  init_operations2();
 });
 
-// src/mcp-server/tools/paymentMethodsGet.ts
-var args37, tool$paymentMethodsGet;
-var init_paymentMethodsGet2 = __esm(() => {
+// src/mcp-server/tools/merchantAccountsList.ts
+var args37, tool$merchantAccountsList;
+var init_merchantAccountsList2 = __esm(() => {
   init_lib();
-  init_paymentMethodsGet();
+  init_merchantAccountsList();
   init_tools();
   args37 = {
-    paymentMethodId: stringType(),
-    merchantAccountId: nullableType(stringType()).optional()
+    cursor: nullableType(stringType()).optional(),
+    limit: numberType().int().default(20),
+    search: nullableType(stringType()).optional()
   };
-  tool$paymentMethodsGet = {
-    name: "payment-methods-get",
-    description: `Get payment method
+  tool$merchantAccountsList = {
+    name: "merchant-accounts-list",
+    description: `List all merchant accounts
 
-Retrieve a payment method.`,
+List all merchant accounts in an instance.`,
     args: args37,
     tool: async (client, args38, ctx) => {
-      const [result, apiCall] = await paymentMethodsGet(client, args38.paymentMethodId, args38.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await merchantAccountsList(client, args38.cursor, args38.limit, args38.search, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      const value = result.value;
+      const value = result.value.result;
       return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/paymentMethodsList.ts
-function paymentMethodsList(client, request, options) {
-  return new APIPromise($do38(client, request, options));
+// src/funcs/merchantAccountsUpdate.ts
+function merchantAccountsUpdate(client, merchantAccountUpdate, merchantAccountId, timeoutInSeconds, options) {
+  return new APIPromise($do38(client, merchantAccountUpdate, merchantAccountId, timeoutInSeconds, options));
 }
-async function $do38(client, request, options) {
-  const parsed = safeParse(request, (value) => ListPaymentMethodsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+async function $do38(client, merchantAccountUpdate, merchantAccountId, timeoutInSeconds, options) {
+  const input = {
+    merchantAccountUpdate,
+    merchantAccountId,
+    timeoutInSeconds
+  };
+  const parsed = safeParse(input, (value) => UpdateMerchantAccountRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
-    return [haltIterator(parsed), { status: "invalid" }];
+    return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
-  const path = pathToFunc("/payment-methods")();
+  const body = encodeJSON("body", payload.MerchantAccountUpdate, {
+    explode: true
+  });
+  const pathParams = {
+    merchant_account_id: encodeSimple("merchant_account_id", payload.merchant_account_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/merchant-accounts/{merchant_account_id}")(pathParams);
   const query = encodeFormQuery({
-    buyer_external_identifier: payload?.buyer_external_identifier,
-    buyer_id: payload?.buyer_id,
-    cursor: payload?.cursor,
-    external_identifier: payload?.external_identifier,
-    limit: payload?.limit,
-    status: payload?.status
+    timeout_in_seconds: payload.timeout_in_seconds
   });
   const headers = new Headers(compactMap({
-    Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload?.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+    "Content-Type": "application/json",
+    Accept: "application/json"
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "list_payment_methods",
+    operationID: "update_merchant_account",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || {
-      strategy: "backoff",
-      backoff: {
-        initialInterval: 200,
-        maxInterval: 200,
-        exponent: 1,
-        maxElapsedTime: 1000
-      },
-      retryConnectionErrors: true
-    },
-    retryCodes: options?.retryCodes || ["5XX"]
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "PUT",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -52421,7 +53033,7 @@ async function $do38(client, request, options) {
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
   if (!requestRes.ok) {
-    return [haltIterator(requestRes), { status: "invalid" }];
+    return [requestRes, { status: "invalid" }];
   }
   const req = requestRes.value;
   const doResult = await client._do(req, {
@@ -52446,105 +53058,80 @@ async function $do38(client, request, options) {
     retryCodes: context.retryCodes
   });
   if (!doResult.ok) {
-    return [haltIterator(doResult), { status: "request-error", request: req }];
+    return [doResult, { status: "request-error", request: req }];
   }
   const response = doResult.value;
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result, raw] = await match(json(200, ListPaymentMethodsResponse$inboundSchema, {
-    key: "Result"
-  }), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentMethodsResponse403ListPaymentMethods$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, MerchantAccount$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, UpdateMerchantAccountResponse403UpdateMerchantAccount$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
-    return [haltIterator(result), {
-      status: "complete",
-      request: req,
-      response
-    }];
+    return [result, { status: "complete", request: req, response }];
   }
-  const nextFunc = (responseData) => {
-    const nextCursor = dlv(responseData, "next_cursor");
-    if (typeof nextCursor !== "string") {
-      return { next: () => null };
-    }
-    const nextVal = () => paymentMethodsList(client, {
-      ...request,
-      cursor: nextCursor
-    }, options);
-    return { next: nextVal, "~next": { cursor: nextCursor } };
-  };
-  const page = { ...result, ...nextFunc(raw) };
-  return [{ ...page, ...createPageIterator(page, (v2) => !v2.ok) }, {
-    status: "complete",
-    request: req,
-    response
-  }];
+  return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsList = __esm(() => {
+var init_merchantAccountsUpdate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
+  init_components();
   init_errors();
   init_operations();
   init_async();
-  init_operations2();
 });
 
-// src/mcp-server/tools/paymentMethodsList.ts
-var args38, tool$paymentMethodsList;
-var init_paymentMethodsList2 = __esm(() => {
-  init_paymentMethodsList();
-  init_operations();
+// src/mcp-server/tools/merchantAccountsUpdate.ts
+var args38, tool$merchantAccountsUpdate;
+var init_merchantAccountsUpdate2 = __esm(() => {
+  init_lib();
+  init_merchantAccountsUpdate();
+  init_components();
   init_tools();
   args38 = {
-    request: ListPaymentMethodsRequest$inboundSchema.optional()
+    merchantAccountUpdate: MerchantAccountUpdate$inboundSchema,
+    merchantAccountId: stringType(),
+    timeoutInSeconds: numberType().default(1)
   };
-  tool$paymentMethodsList = {
-    name: "payment-methods-list",
-    description: `List all payment methods
+  tool$merchantAccountsUpdate = {
+    name: "merchant-accounts-update",
+    description: `Update a merchant account
 
-List all stored payment method.`,
+Update info for a merchant account in an instance.`,
     args: args38,
     tool: async (client, args39, ctx) => {
-      const [result, apiCall] = await paymentMethodsList(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await merchantAccountsUpdate(client, args39.merchantAccountUpdate, args39.merchantAccountId, args39.timeoutInSeconds, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      const value = result.value.result;
+      const value = result.value;
       return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/paymentMethodsNetworkTokensCreate.ts
-function paymentMethodsNetworkTokensCreate(client, networkTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do39(client, networkTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentMethodsCreate.ts
+function paymentMethodsCreate(client, requestBody, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do39(client, requestBody, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do39(client, networkTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options) {
+async function $do39(client, requestBody, timeoutInSeconds, merchantAccountId, options) {
   const input = {
-    networkTokenCreate,
-    paymentMethodId,
+    requestBody,
     timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => CreatePaymentMethodNetworkTokenRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => CreatePaymentMethodRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.NetworkTokenCreate, {
-    explode: true
-  });
-  const pathParams = {
-    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
-  };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens")(pathParams);
+  const body = encodeJSON("body", payload.RequestBody, { explode: true });
+  const path = pathToFunc("/payment-methods")();
   const query = encodeFormQuery({
     timeout_in_seconds: payload.timeout_in_seconds
   });
@@ -52558,7 +53145,7 @@ async function $do39(client, networkTokenCreate, paymentMethodId, timeoutInSecon
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create_payment_method_network_token",
+    operationID: "create_payment_method",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -52607,13 +53194,13 @@ async function $do39(client, networkTokenCreate, paymentMethodId, timeoutInSecon
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, NetworkToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentMethodNetworkTokenResponse403CreatePaymentMethodNetworkToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, PaymentMethod$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentMethodResponse403CreatePaymentMethod$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsNetworkTokensCreate = __esm(() => {
+var init_paymentMethodsCreate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -52626,27 +53213,26 @@ var init_paymentMethodsNetworkTokensCreate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsNetworkTokensCreate.ts
-var args39, tool$paymentMethodsNetworkTokensCreate;
-var init_paymentMethodsNetworkTokensCreate2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsCreate.ts
+var args39, tool$paymentMethodsCreate;
+var init_paymentMethodsCreate2 = __esm(() => {
   init_lib();
-  init_paymentMethodsNetworkTokensCreate();
-  init_components();
+  init_paymentMethodsCreate();
+  init_operations();
   init_tools();
   args39 = {
-    networkTokenCreate: NetworkTokenCreate$inboundSchema,
-    paymentMethodId: stringType(),
+    requestBody: CreatePaymentMethodBody$inboundSchema,
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$paymentMethodsNetworkTokensCreate = {
-    name: "payment-methods-network-tokens-create",
-    description: `Provision network token
+  tool$paymentMethodsCreate = {
+    name: "payment-methods-create",
+    description: `Create payment method
 
-Provision a network token for a payment method.`,
+Store a new payment method.`,
     args: args39,
     tool: async (client, args40, ctx) => {
-      const [result, apiCall] = await paymentMethodsNetworkTokensCreate(client, args40.networkTokenCreate, args40.paymentMethodId, args40.timeoutInSeconds, args40.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsCreate(client, args40.requestBody, args40.timeoutInSeconds, args40.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -52659,27 +53245,26 @@ Provision a network token for a payment method.`,
   };
 });
 
-// src/funcs/paymentMethodsNetworkTokensCryptogramCreate.ts
-function paymentMethodsNetworkTokensCryptogramCreate(client, request, options) {
-  return new APIPromise($do40(client, request, options));
+// src/funcs/paymentMethodsDelete.ts
+function paymentMethodsDelete(client, paymentMethodId, merchantAccountId, options) {
+  return new APIPromise($do40(client, paymentMethodId, merchantAccountId, options));
 }
-async function $do40(client, request, options) {
-  const parsed = safeParse(request, (value) => CreatePaymentMethodNetworkTokenCryptogramRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do40(client, paymentMethodId, merchantAccountId, options) {
+  const input = {
+    paymentMethodId,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => DeletePaymentMethodRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.CryptogramCreate, { explode: true });
+  const body = null;
   const pathParams = {
-    network_token_id: encodeSimple("network_token_id", payload.network_token_id, { explode: false, charEncoding: "percent" }),
     payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens/{network_token_id}/cryptogram")(pathParams);
-  const query = encodeFormQuery({
-    timeout_in_seconds: payload.timeout_in_seconds
-  });
+  const path = pathToFunc("/payment-methods/{payment_method_id}")(pathParams);
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
@@ -52688,7 +53273,7 @@ async function $do40(client, request, options) {
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create_payment_method_network_token_cryptogram",
+    operationID: "delete_payment_method",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -52697,11 +53282,10 @@ async function $do40(client, request, options) {
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "DELETE",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
@@ -52737,79 +53321,73 @@ async function $do40(client, request, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, Cryptogram$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentMethodNetworkTokenCryptogramResponse403CreatePaymentMethodNetworkTokenCryptogram$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, DeletePaymentMethodResponse403DeletePaymentMethod$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsNetworkTokensCryptogramCreate = __esm(() => {
+var init_paymentMethodsDelete = __esm(() => {
+  init_lib();
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
-  init_components();
   init_errors();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsNetworkTokensCryptogramCreate.ts
-var args40, tool$paymentMethodsNetworkTokensCryptogramCreate;
-var init_paymentMethodsNetworkTokensCryptogramCreate2 = __esm(() => {
-  init_paymentMethodsNetworkTokensCryptogramCreate();
-  init_operations();
+// src/mcp-server/tools/paymentMethodsDelete.ts
+var args40, tool$paymentMethodsDelete;
+var init_paymentMethodsDelete2 = __esm(() => {
+  init_lib();
+  init_paymentMethodsDelete();
   init_tools();
   args40 = {
-    request: CreatePaymentMethodNetworkTokenCryptogramRequest$inboundSchema
+    paymentMethodId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$paymentMethodsNetworkTokensCryptogramCreate = {
-    name: "payment-methods-network-tokens-cryptogram-create",
-    description: `Provision network token cryptogram
+  tool$paymentMethodsDelete = {
+    name: "payment-methods-delete",
+    description: `Delete payment method
 
-Provision a cryptogram for a network token.`,
+Delete a payment method.`,
     args: args40,
     tool: async (client, args41, ctx) => {
-      const [result, apiCall] = await paymentMethodsNetworkTokensCryptogramCreate(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsDelete(client, args41.paymentMethodId, args41.merchantAccountId, { 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);
+      return formatResult(undefined, apiCall);
     }
   };
 });
 
-// src/funcs/paymentMethodsNetworkTokensDelete.ts
-function paymentMethodsNetworkTokensDelete(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do41(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentMethodsGet.ts
+function paymentMethodsGet(client, paymentMethodId, merchantAccountId, options) {
+  return new APIPromise($do41(client, paymentMethodId, merchantAccountId, options));
 }
-async function $do41(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
+async function $do41(client, paymentMethodId, merchantAccountId, options) {
   const input = {
     paymentMethodId,
-    networkTokenId,
-    timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => DeletePaymentMethodNetworkTokenRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => GetPaymentMethodRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
   const pathParams = {
-    network_token_id: encodeSimple("network_token_id", payload.network_token_id, { explode: false, charEncoding: "percent" }),
     payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens/{network_token_id}")(pathParams);
-  const query = encodeFormQuery({
-    timeout_in_seconds: payload.timeout_in_seconds
-  });
+  const path = pathToFunc("/payment-methods/{payment_method_id}")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
@@ -52819,20 +53397,28 @@ async function $do41(client, paymentMethodId, networkTokenId, timeoutInSeconds,
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "delete_payment_method_network_token",
+    operationID: "get_payment_method",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "DELETE",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
@@ -52868,85 +53454,85 @@ async function $do41(client, paymentMethodId, networkTokenId, timeoutInSeconds,
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, DeletePaymentMethodNetworkTokenResponse403DeletePaymentMethodNetworkToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, PaymentMethod$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetPaymentMethodResponse403GetPaymentMethod$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsNetworkTokensDelete = __esm(() => {
-  init_lib();
+var init_paymentMethodsGet = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
+  init_components();
   init_errors();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsNetworkTokensDelete.ts
-var args41, tool$paymentMethodsNetworkTokensDelete;
-var init_paymentMethodsNetworkTokensDelete2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsGet.ts
+var args41, tool$paymentMethodsGet;
+var init_paymentMethodsGet2 = __esm(() => {
   init_lib();
-  init_paymentMethodsNetworkTokensDelete();
+  init_paymentMethodsGet();
   init_tools();
   args41 = {
     paymentMethodId: stringType(),
-    networkTokenId: stringType(),
-    timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$paymentMethodsNetworkTokensDelete = {
-    name: "payment-methods-network-tokens-delete",
-    description: `Delete network token
+  tool$paymentMethodsGet = {
+    name: "payment-methods-get",
+    description: `Get payment method
 
-Delete a network token for a payment method.`,
+Retrieve a payment method.`,
     args: args41,
     tool: async (client, args42, ctx) => {
-      const [result, apiCall] = await paymentMethodsNetworkTokensDelete(client, args42.paymentMethodId, args42.networkTokenId, args42.timeoutInSeconds, args42.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsGet(client, args42.paymentMethodId, args42.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      return formatResult(undefined, apiCall);
+      const value = result.value;
+      return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/paymentMethodsNetworkTokensList.ts
-function paymentMethodsNetworkTokensList(client, paymentMethodId, merchantAccountId, options) {
-  return new APIPromise($do42(client, paymentMethodId, merchantAccountId, options));
+// src/funcs/paymentMethodsList.ts
+function paymentMethodsList(client, request, options) {
+  return new APIPromise($do42(client, request, options));
 }
-async function $do42(client, paymentMethodId, merchantAccountId, options) {
-  const input = {
-    paymentMethodId,
-    merchantAccountId
-  };
-  const parsed = safeParse(input, (value) => ListPaymentMethodNetworkTokensRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do42(client, request, options) {
+  const parsed = safeParse(request, (value) => ListPaymentMethodsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
-    return [parsed, { status: "invalid" }];
+    return [haltIterator(parsed), { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
-  const pathParams = {
-    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
-  };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens")(pathParams);
+  const path = pathToFunc("/payment-methods")();
+  const query = encodeFormQuery({
+    buyer_external_identifier: payload?.buyer_external_identifier,
+    buyer_id: payload?.buyer_id,
+    cursor: payload?.cursor,
+    external_identifier: payload?.external_identifier,
+    limit: payload?.limit,
+    status: payload?.status
+  });
   const headers = new Headers(compactMap({
     Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload?.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "list_payment_method_network_tokens",
+    operationID: "list_payment_methods",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -52968,11 +53554,12 @@ async function $do42(client, paymentMethodId, merchantAccountId, options) {
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
   if (!requestRes.ok) {
-    return [requestRes, { status: "invalid" }];
+    return [haltIterator(requestRes), { status: "invalid" }];
   }
   const req = requestRes.value;
   const doResult = await client._do(req, {
@@ -52997,87 +53584,110 @@ async function $do42(client, paymentMethodId, merchantAccountId, options) {
     retryCodes: context.retryCodes
   });
   if (!doResult.ok) {
-    return [doResult, { status: "request-error", request: req }];
+    return [haltIterator(doResult), { status: "request-error", request: req }];
   }
   const response = doResult.value;
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, CollectionNoCursorNetworkToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentMethodNetworkTokensResponse403ListPaymentMethodNetworkTokens$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result, raw] = await match(json(200, ListPaymentMethodsResponse$inboundSchema, {
+    key: "Result"
+  }), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentMethodsResponse403ListPaymentMethods$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
-    return [result, { status: "complete", request: req, response }];
+    return [haltIterator(result), {
+      status: "complete",
+      request: req,
+      response
+    }];
   }
-  return [result, { status: "complete", request: req, response }];
+  const nextFunc = (responseData) => {
+    const nextCursor = dlv(responseData, "next_cursor");
+    if (typeof nextCursor !== "string") {
+      return { next: () => null };
+    }
+    const nextVal = () => paymentMethodsList(client, {
+      ...request,
+      cursor: nextCursor
+    }, options);
+    return { next: nextVal, "~next": { cursor: nextCursor } };
+  };
+  const page = { ...result, ...nextFunc(raw) };
+  return [{ ...page, ...createPageIterator(page, (v2) => !v2.ok) }, {
+    status: "complete",
+    request: req,
+    response
+  }];
 }
-var init_paymentMethodsNetworkTokensList = __esm(() => {
+var init_paymentMethodsList = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
-  init_components();
   init_errors();
   init_operations();
   init_async();
+  init_operations2();
 });
 
-// src/mcp-server/tools/paymentMethodsNetworkTokensList.ts
-var args42, tool$paymentMethodsNetworkTokensList;
-var init_paymentMethodsNetworkTokensList2 = __esm(() => {
-  init_lib();
-  init_paymentMethodsNetworkTokensList();
+// src/mcp-server/tools/paymentMethodsList.ts
+var args42, tool$paymentMethodsList;
+var init_paymentMethodsList2 = __esm(() => {
+  init_paymentMethodsList();
+  init_operations();
   init_tools();
   args42 = {
-    paymentMethodId: stringType(),
-    merchantAccountId: nullableType(stringType()).optional()
+    request: ListPaymentMethodsRequest$inboundSchema.optional()
   };
-  tool$paymentMethodsNetworkTokensList = {
-    name: "payment-methods-network-tokens-list",
-    description: `List network tokens
+  tool$paymentMethodsList = {
+    name: "payment-methods-list",
+    description: `List all payment methods
 
-List all network tokens stored for a payment method.`,
+List all stored payment method.`,
     args: args42,
     tool: async (client, args43, ctx) => {
-      const [result, apiCall] = await paymentMethodsNetworkTokensList(client, args43.paymentMethodId, args43.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsList(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      const value = result.value;
+      const value = result.value.result;
       return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/paymentMethodsNetworkTokensResume.ts
-function paymentMethodsNetworkTokensResume(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do43(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentMethodsNetworkTokensCreate.ts
+function paymentMethodsNetworkTokensCreate(client, networkTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do43(client, networkTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do43(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
+async function $do43(client, networkTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
+    networkTokenCreate,
     paymentMethodId,
-    networkTokenId,
     timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => ResumePaymentMethodNetworkTokenRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => CreatePaymentMethodNetworkTokenRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = encodeJSON("body", payload.NetworkTokenCreate, {
+    explode: true
+  });
   const pathParams = {
-    network_token_id: encodeSimple("network_token_id", payload.network_token_id, { explode: false, charEncoding: "percent" }),
     payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens/{network_token_id}/resume")(pathParams);
+  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens")(pathParams);
   const query = encodeFormQuery({
     timeout_in_seconds: payload.timeout_in_seconds
   });
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
@@ -53086,7 +53696,7 @@ async function $do43(client, paymentMethodId, networkTokenId, timeoutInSeconds,
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "resume_payment_method_network_token",
+    operationID: "create_payment_method_network_token",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -53135,13 +53745,13 @@ async function $do43(client, paymentMethodId, networkTokenId, timeoutInSeconds,
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, NetworkToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ResumePaymentMethodNetworkTokenResponse403ResumePaymentMethodNetworkToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, NetworkToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentMethodNetworkTokenResponse403CreatePaymentMethodNetworkToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsNetworkTokensResume = __esm(() => {
+var init_paymentMethodsNetworkTokensCreate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -53154,26 +53764,27 @@ var init_paymentMethodsNetworkTokensResume = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsNetworkTokensResume.ts
-var args43, tool$paymentMethodsNetworkTokensResume;
-var init_paymentMethodsNetworkTokensResume2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsNetworkTokensCreate.ts
+var args43, tool$paymentMethodsNetworkTokensCreate;
+var init_paymentMethodsNetworkTokensCreate2 = __esm(() => {
   init_lib();
-  init_paymentMethodsNetworkTokensResume();
+  init_paymentMethodsNetworkTokensCreate();
+  init_components();
   init_tools();
   args43 = {
+    networkTokenCreate: NetworkTokenCreate$inboundSchema,
     paymentMethodId: stringType(),
-    networkTokenId: stringType(),
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$paymentMethodsNetworkTokensResume = {
-    name: "payment-methods-network-tokens-resume",
-    description: `Resume network token
+  tool$paymentMethodsNetworkTokensCreate = {
+    name: "payment-methods-network-tokens-create",
+    description: `Provision network token
 
-Resume a suspended network token for a payment method.`,
+Provision a network token for a payment method.`,
     args: args43,
     tool: async (client, args44, ctx) => {
-      const [result, apiCall] = await paymentMethodsNetworkTokensResume(client, args44.paymentMethodId, args44.networkTokenId, args44.timeoutInSeconds, args44.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsNetworkTokensCreate(client, args44.networkTokenCreate, args44.paymentMethodId, args44.timeoutInSeconds, args44.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53186,32 +53797,27 @@ Resume a suspended network token for a payment method.`,
   };
 });
 
-// src/funcs/paymentMethodsNetworkTokensSuspend.ts
-function paymentMethodsNetworkTokensSuspend(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do44(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentMethodsNetworkTokensCryptogramCreate.ts
+function paymentMethodsNetworkTokensCryptogramCreate(client, request, options) {
+  return new APIPromise($do44(client, request, options));
 }
-async function $do44(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
-  const input = {
-    paymentMethodId,
-    networkTokenId,
-    timeoutInSeconds,
-    merchantAccountId
-  };
-  const parsed = safeParse(input, (value) => SuspendPaymentMethodNetworkTokenRequest$outboundSchema.parse(value), "Input validation failed");
+async function $do44(client, request, options) {
+  const parsed = safeParse(request, (value) => CreatePaymentMethodNetworkTokenCryptogramRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = null;
+  const body = encodeJSON("body", payload.CryptogramCreate, { explode: true });
   const pathParams = {
     network_token_id: encodeSimple("network_token_id", payload.network_token_id, { explode: false, charEncoding: "percent" }),
     payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens/{network_token_id}/suspend")(pathParams);
+  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens/{network_token_id}/cryptogram")(pathParams);
   const query = encodeFormQuery({
     timeout_in_seconds: payload.timeout_in_seconds
   });
   const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
@@ -53220,7 +53826,7 @@ async function $do44(client, paymentMethodId, networkTokenId, timeoutInSeconds,
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "suspend_payment_method_network_token",
+    operationID: "create_payment_method_network_token_cryptogram",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -53269,13 +53875,13 @@ async function $do44(client, paymentMethodId, networkTokenId, timeoutInSeconds,
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, NetworkToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, SuspendPaymentMethodNetworkTokenResponse403SuspendPaymentMethodNetworkToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, Cryptogram$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentMethodNetworkTokenCryptogramResponse403CreatePaymentMethodNetworkTokenCryptogram$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsNetworkTokensSuspend = __esm(() => {
+var init_paymentMethodsNetworkTokensCryptogramCreate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -53288,26 +53894,23 @@ var init_paymentMethodsNetworkTokensSuspend = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsNetworkTokensSuspend.ts
-var args44, tool$paymentMethodsNetworkTokensSuspend;
-var init_paymentMethodsNetworkTokensSuspend2 = __esm(() => {
-  init_lib();
-  init_paymentMethodsNetworkTokensSuspend();
+// src/mcp-server/tools/paymentMethodsNetworkTokensCryptogramCreate.ts
+var args44, tool$paymentMethodsNetworkTokensCryptogramCreate;
+var init_paymentMethodsNetworkTokensCryptogramCreate2 = __esm(() => {
+  init_paymentMethodsNetworkTokensCryptogramCreate();
+  init_operations();
   init_tools();
   args44 = {
-    paymentMethodId: stringType(),
-    networkTokenId: stringType(),
-    timeoutInSeconds: numberType().default(1),
-    merchantAccountId: nullableType(stringType()).optional()
+    request: CreatePaymentMethodNetworkTokenCryptogramRequest$inboundSchema
   };
-  tool$paymentMethodsNetworkTokensSuspend = {
-    name: "payment-methods-network-tokens-suspend",
-    description: `Suspend network token
+  tool$paymentMethodsNetworkTokensCryptogramCreate = {
+    name: "payment-methods-network-tokens-cryptogram-create",
+    description: `Provision network token cryptogram
 
-Suspend a network token for a payment method.`,
+Provision a cryptogram for a network token.`,
     args: args44,
     tool: async (client, args45, ctx) => {
-      const [result, apiCall] = await paymentMethodsNetworkTokensSuspend(client, args45.paymentMethodId, args45.networkTokenId, args45.timeoutInSeconds, args45.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsNetworkTokensCryptogramCreate(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53320,34 +53923,32 @@ Suspend a network token for a payment method.`,
   };
 });
 
-// src/funcs/paymentMethodsPaymentServiceTokensCreate.ts
-function paymentMethodsPaymentServiceTokensCreate(client, paymentServiceTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do45(client, paymentServiceTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentMethodsNetworkTokensDelete.ts
+function paymentMethodsNetworkTokensDelete(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do45(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do45(client, paymentServiceTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options) {
+async function $do45(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
-    paymentServiceTokenCreate,
     paymentMethodId,
+    networkTokenId,
     timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => CreatePaymentMethodPaymentServiceTokenRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => DeletePaymentMethodNetworkTokenRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.PaymentServiceTokenCreate, {
-    explode: true
-  });
+  const body = null;
   const pathParams = {
+    network_token_id: encodeSimple("network_token_id", payload.network_token_id, { explode: false, charEncoding: "percent" }),
     payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/payment-service-tokens")(pathParams);
+  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens/{network_token_id}")(pathParams);
   const query = encodeFormQuery({
     timeout_in_seconds: payload.timeout_in_seconds
   });
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
@@ -53356,7 +53957,7 @@ async function $do45(client, paymentServiceTokenCreate, paymentMethodId, timeout
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create_payment_method_payment_service_token",
+    operationID: "delete_payment_method_network_token",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -53365,7 +53966,7 @@ async function $do45(client, paymentServiceTokenCreate, paymentMethodId, timeout
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "POST",
+    method: "DELETE",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -53405,83 +54006,75 @@ async function $do45(client, paymentServiceTokenCreate, paymentMethodId, timeout
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, PaymentServiceToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentMethodPaymentServiceTokenResponse403CreatePaymentMethodPaymentServiceToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, DeletePaymentMethodNetworkTokenResponse403DeletePaymentMethodNetworkToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsPaymentServiceTokensCreate = __esm(() => {
+var init_paymentMethodsNetworkTokensDelete = __esm(() => {
+  init_lib();
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
-  init_components();
   init_errors();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsPaymentServiceTokensCreate.ts
-var args45, tool$paymentMethodsPaymentServiceTokensCreate;
-var init_paymentMethodsPaymentServiceTokensCreate2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsNetworkTokensDelete.ts
+var args45, tool$paymentMethodsNetworkTokensDelete;
+var init_paymentMethodsNetworkTokensDelete2 = __esm(() => {
   init_lib();
-  init_paymentMethodsPaymentServiceTokensCreate();
-  init_components();
+  init_paymentMethodsNetworkTokensDelete();
   init_tools();
   args45 = {
-    paymentServiceTokenCreate: PaymentServiceTokenCreate$inboundSchema,
     paymentMethodId: stringType(),
+    networkTokenId: stringType(),
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$paymentMethodsPaymentServiceTokensCreate = {
-    name: "payment-methods-payment-service-tokens-create",
-    description: `Create payment service token
+  tool$paymentMethodsNetworkTokensDelete = {
+    name: "payment-methods-network-tokens-delete",
+    description: `Delete network token
 
-Create a gateway tokens for a payment method.`,
+Delete a network token for a payment method.`,
     args: args45,
     tool: async (client, args46, ctx) => {
-      const [result, apiCall] = await paymentMethodsPaymentServiceTokensCreate(client, args46.paymentServiceTokenCreate, args46.paymentMethodId, args46.timeoutInSeconds, args46.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsNetworkTokensDelete(client, args46.paymentMethodId, args46.networkTokenId, args46.timeoutInSeconds, args46.merchantAccountId, { 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);
+      return formatResult(undefined, apiCall);
     }
   };
 });
 
-// src/funcs/paymentMethodsPaymentServiceTokensDelete.ts
-function paymentMethodsPaymentServiceTokensDelete(client, paymentMethodId, paymentServiceTokenId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do46(client, paymentMethodId, paymentServiceTokenId, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentMethodsNetworkTokensList.ts
+function paymentMethodsNetworkTokensList(client, paymentMethodId, merchantAccountId, options) {
+  return new APIPromise($do46(client, paymentMethodId, merchantAccountId, options));
 }
-async function $do46(client, paymentMethodId, paymentServiceTokenId, timeoutInSeconds, merchantAccountId, options) {
+async function $do46(client, paymentMethodId, merchantAccountId, options) {
   const input = {
     paymentMethodId,
-    paymentServiceTokenId,
-    timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => DeletePaymentMethodPaymentServiceTokenRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => ListPaymentMethodNetworkTokensRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
   const pathParams = {
-    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" }),
-    payment_service_token_id: encodeSimple("payment_service_token_id", payload.payment_service_token_id, { explode: false, charEncoding: "percent" })
+    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/payment-service-tokens/{payment_service_token_id}")(pathParams);
-  const query = encodeFormQuery({
-    timeout_in_seconds: payload.timeout_in_seconds
-  });
+  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens")(pathParams);
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
@@ -53491,20 +54084,28 @@ async function $do46(client, paymentMethodId, paymentServiceTokenId, timeoutInSe
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "delete_payment_method_payment_service_token",
+    operationID: "list_payment_method_network_tokens",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
-    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "DELETE",
+    method: "GET",
     baseURL: options?.serverURL,
     path,
     headers,
-    query,
     body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
@@ -53540,78 +54141,79 @@ async function $do46(client, paymentMethodId, paymentServiceTokenId, timeoutInSe
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(nil(204, voidType()), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, DeletePaymentMethodPaymentServiceTokenResponse403DeletePaymentMethodPaymentServiceToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, CollectionNoCursorNetworkToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentMethodNetworkTokensResponse403ListPaymentMethodNetworkTokens$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsPaymentServiceTokensDelete = __esm(() => {
-  init_lib();
+var init_paymentMethodsNetworkTokensList = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
+  init_components();
   init_errors();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsPaymentServiceTokensDelete.ts
-var args46, tool$paymentMethodsPaymentServiceTokensDelete;
-var init_paymentMethodsPaymentServiceTokensDelete2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsNetworkTokensList.ts
+var args46, tool$paymentMethodsNetworkTokensList;
+var init_paymentMethodsNetworkTokensList2 = __esm(() => {
   init_lib();
-  init_paymentMethodsPaymentServiceTokensDelete();
+  init_paymentMethodsNetworkTokensList();
   init_tools();
   args46 = {
     paymentMethodId: stringType(),
-    paymentServiceTokenId: stringType(),
-    timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$paymentMethodsPaymentServiceTokensDelete = {
-    name: "payment-methods-payment-service-tokens-delete",
-    description: `Delete payment service token
+  tool$paymentMethodsNetworkTokensList = {
+    name: "payment-methods-network-tokens-list",
+    description: `List network tokens
 
-Delete a gateway tokens for a payment method.`,
+List all network tokens stored for a payment method.`,
     args: args46,
     tool: async (client, args47, ctx) => {
-      const [result, apiCall] = await paymentMethodsPaymentServiceTokensDelete(client, args47.paymentMethodId, args47.paymentServiceTokenId, args47.timeoutInSeconds, args47.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsNetworkTokensList(client, args47.paymentMethodId, args47.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
           isError: true
         };
       }
-      return formatResult(undefined, apiCall);
+      const value = result.value;
+      return formatResult(value, apiCall);
     }
   };
 });
 
-// src/funcs/paymentMethodsPaymentServiceTokensList.ts
-function paymentMethodsPaymentServiceTokensList(client, paymentMethodId, paymentServiceId, merchantAccountId, options) {
-  return new APIPromise($do47(client, paymentMethodId, paymentServiceId, merchantAccountId, options));
+// src/funcs/paymentMethodsNetworkTokensResume.ts
+function paymentMethodsNetworkTokensResume(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do47(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do47(client, paymentMethodId, paymentServiceId, merchantAccountId, options) {
+async function $do47(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     paymentMethodId,
-    paymentServiceId,
+    networkTokenId,
+    timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => ListPaymentMethodPaymentServiceTokensRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => ResumePaymentMethodNetworkTokenRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
   const pathParams = {
+    network_token_id: encodeSimple("network_token_id", payload.network_token_id, { explode: false, charEncoding: "percent" }),
     payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payment-methods/{payment_method_id}/payment-service-tokens")(pathParams);
+  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens/{network_token_id}/resume")(pathParams);
   const query = encodeFormQuery({
-    payment_service_id: payload.payment_service_id
+    timeout_in_seconds: payload.timeout_in_seconds
   });
   const headers = new Headers(compactMap({
     Accept: "application/json",
@@ -53622,25 +54224,16 @@ async function $do47(client, paymentMethodId, paymentServiceId, merchantAccountI
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "list_payment_method_payment_service_tokens",
+    operationID: "resume_payment_method_network_token",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || {
-      strategy: "backoff",
-      backoff: {
-        initialInterval: 200,
-        maxInterval: 200,
-        exponent: 1,
-        maxElapsedTime: 1000
-      },
-      retryConnectionErrors: true
-    },
-    retryCodes: options?.retryCodes || ["5XX"]
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "POST",
     baseURL: options?.serverURL,
     path,
     headers,
@@ -53680,13 +54273,13 @@ async function $do47(client, paymentMethodId, paymentServiceId, merchantAccountI
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, CollectionNoCursorPaymentServiceToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentMethodPaymentServiceTokensResponse403ListPaymentMethodPaymentServiceTokens$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, NetworkToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ResumePaymentMethodNetworkTokenResponse403ResumePaymentMethodNetworkToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentMethodsPaymentServiceTokensList = __esm(() => {
+var init_paymentMethodsNetworkTokensResume = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -53699,25 +54292,26 @@ var init_paymentMethodsPaymentServiceTokensList = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/paymentMethodsPaymentServiceTokensList.ts
-var args47, tool$paymentMethodsPaymentServiceTokensList;
-var init_paymentMethodsPaymentServiceTokensList2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsNetworkTokensResume.ts
+var args47, tool$paymentMethodsNetworkTokensResume;
+var init_paymentMethodsNetworkTokensResume2 = __esm(() => {
   init_lib();
-  init_paymentMethodsPaymentServiceTokensList();
+  init_paymentMethodsNetworkTokensResume();
   init_tools();
   args47 = {
     paymentMethodId: stringType(),
-    paymentServiceId: nullableType(stringType()).optional(),
+    networkTokenId: stringType(),
+    timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$paymentMethodsPaymentServiceTokensList = {
-    name: "payment-methods-payment-service-tokens-list",
-    description: `List payment service tokens
+  tool$paymentMethodsNetworkTokensResume = {
+    name: "payment-methods-network-tokens-resume",
+    description: `Resume network token
 
-List all gateway tokens stored for a payment method.`,
+Resume a suspended network token for a payment method.`,
     args: args47,
     tool: async (client, args48, ctx) => {
-      const [result, apiCall] = await paymentMethodsPaymentServiceTokensList(client, args48.paymentMethodId, args48.paymentServiceId, args48.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsNetworkTokensResume(client, args48.paymentMethodId, args48.networkTokenId, args48.timeoutInSeconds, args48.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53730,26 +54324,32 @@ List all gateway tokens stored for a payment method.`,
   };
 });
 
-// src/funcs/paymentOptionsList.ts
-function paymentOptionsList(client, paymentOptionRequest, merchantAccountId, options) {
-  return new APIPromise($do48(client, paymentOptionRequest, merchantAccountId, options));
+// src/funcs/paymentMethodsNetworkTokensSuspend.ts
+function paymentMethodsNetworkTokensSuspend(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do48(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do48(client, paymentOptionRequest, merchantAccountId, options) {
+async function $do48(client, paymentMethodId, networkTokenId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
-    paymentOptionRequest,
+    paymentMethodId,
+    networkTokenId,
+    timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => ListPaymentOptionsRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => SuspendPaymentMethodNetworkTokenRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.PaymentOptionRequest, {
-    explode: true
+  const body = null;
+  const pathParams = {
+    network_token_id: encodeSimple("network_token_id", payload.network_token_id, { explode: false, charEncoding: "percent" }),
+    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/payment-methods/{payment_method_id}/network-tokens/{network_token_id}/suspend")(pathParams);
+  const query = encodeFormQuery({
+    timeout_in_seconds: payload.timeout_in_seconds
   });
-  const path = pathToFunc("/payment-options")();
   const headers = new Headers(compactMap({
-    "Content-Type": "application/json",
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
@@ -53758,7 +54358,7 @@ async function $do48(client, paymentOptionRequest, merchantAccountId, options) {
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "list_payment_options",
+    operationID: "suspend_payment_method_network_token",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -53771,6 +54371,7 @@ async function $do48(client, paymentOptionRequest, merchantAccountId, options) {
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
@@ -53806,13 +54407,13 @@ async function $do48(client, paymentOptionRequest, merchantAccountId, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, CollectionNoCursorPaymentOption$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentOptionsResponse403ListPaymentOptions$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(200, NetworkToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, SuspendPaymentMethodNetworkTokenResponse403SuspendPaymentMethodNetworkToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_paymentOptionsList = __esm(() => {
+var init_paymentMethodsNetworkTokensSuspend = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -53825,25 +54426,26 @@ var init_paymentOptionsList = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/paymentOptionsList.ts
-var args48, tool$paymentOptionsList;
-var init_paymentOptionsList2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsNetworkTokensSuspend.ts
+var args48, tool$paymentMethodsNetworkTokensSuspend;
+var init_paymentMethodsNetworkTokensSuspend2 = __esm(() => {
   init_lib();
-  init_paymentOptionsList();
-  init_components();
+  init_paymentMethodsNetworkTokensSuspend();
   init_tools();
   args48 = {
-    paymentOptionRequest: PaymentOptionRequest$inboundSchema,
+    paymentMethodId: stringType(),
+    networkTokenId: stringType(),
+    timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$paymentOptionsList = {
-    name: "payment-options-list",
-    description: `List payment options
+  tool$paymentMethodsNetworkTokensSuspend = {
+    name: "payment-methods-network-tokens-suspend",
+    description: `Suspend network token
 
-List the payment options available at checkout. filtering by country, currency, and additional fields passed to Flow rules.`,
+Suspend a network token for a payment method.`,
     args: args48,
     tool: async (client, args49, ctx) => {
-      const [result, apiCall] = await paymentOptionsList(client, args49.paymentOptionRequest, args49.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsNetworkTokensSuspend(client, args49.paymentMethodId, args49.networkTokenId, args49.timeoutInSeconds, args49.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53856,23 +54458,29 @@ List the payment options available at checkout. filtering by country, currency,
   };
 });
 
-// src/funcs/payoutsCreate.ts
-function payoutsCreate(client, payoutCreate, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do49(client, payoutCreate, timeoutInSeconds, merchantAccountId, options));
+// src/funcs/paymentMethodsPaymentServiceTokensCreate.ts
+function paymentMethodsPaymentServiceTokensCreate(client, paymentServiceTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do49(client, paymentServiceTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do49(client, payoutCreate, timeoutInSeconds, merchantAccountId, options) {
+async function $do49(client, paymentServiceTokenCreate, paymentMethodId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
-    payoutCreate,
+    paymentServiceTokenCreate,
+    paymentMethodId,
     timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => CreatePayoutRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => CreatePaymentMethodPaymentServiceTokenRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
-  const body = encodeJSON("body", payload.PayoutCreate, { explode: true });
-  const path = pathToFunc("/payouts")();
+  const body = encodeJSON("body", payload.PaymentServiceTokenCreate, {
+    explode: true
+  });
+  const pathParams = {
+    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/payment-methods/{payment_method_id}/payment-service-tokens")(pathParams);
   const query = encodeFormQuery({
     timeout_in_seconds: payload.timeout_in_seconds
   });
@@ -53886,7 +54494,7 @@ async function $do49(client, payoutCreate, timeoutInSeconds, merchantAccountId,
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "create_payout",
+    operationID: "create_payment_method_payment_service_token",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -53935,13 +54543,13 @@ async function $do49(client, payoutCreate, timeoutInSeconds, merchantAccountId,
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(201, PayoutSummary$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePayoutResponse403CreatePayout$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(json(201, PaymentServiceToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePaymentMethodPaymentServiceTokenResponse403CreatePaymentMethodPaymentServiceToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_payoutsCreate = __esm(() => {
+var init_paymentMethodsPaymentServiceTokensCreate = __esm(() => {
   init_encodings();
   init_matchers();
   init_primitives();
@@ -53954,26 +54562,27 @@ var init_payoutsCreate = __esm(() => {
   init_async();
 });
 
-// src/mcp-server/tools/payoutsCreate.ts
-var args49, tool$payoutsCreate;
-var init_payoutsCreate2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsPaymentServiceTokensCreate.ts
+var args49, tool$paymentMethodsPaymentServiceTokensCreate;
+var init_paymentMethodsPaymentServiceTokensCreate2 = __esm(() => {
   init_lib();
-  init_payoutsCreate();
+  init_paymentMethodsPaymentServiceTokensCreate();
   init_components();
   init_tools();
   args49 = {
-    payoutCreate: PayoutCreate$inboundSchema,
+    paymentServiceTokenCreate: PaymentServiceTokenCreate$inboundSchema,
+    paymentMethodId: stringType(),
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$payoutsCreate = {
-    name: "payouts-create",
-    description: `Create a payout.
+  tool$paymentMethodsPaymentServiceTokensCreate = {
+    name: "payment-methods-payment-service-tokens-create",
+    description: `Create payment service token
 
-Creates a new payout.`,
+Create a gateway tokens for a payment method.`,
     args: args49,
     tool: async (client, args50, ctx) => {
-      const [result, apiCall] = await payoutsCreate(client, args50.payoutCreate, args50.timeoutInSeconds, args50.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsPaymentServiceTokensCreate(client, args50.paymentServiceTokenCreate, args50.paymentMethodId, args50.timeoutInSeconds, args50.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -53986,28 +54595,31 @@ Creates a new payout.`,
   };
 });
 
-// src/funcs/payoutsGet.ts
-function payoutsGet(client, payoutId, merchantAccountId, options) {
-  return new APIPromise($do50(client, payoutId, merchantAccountId, options));
+// src/funcs/paymentMethodsPaymentServiceTokensDelete.ts
+function paymentMethodsPaymentServiceTokensDelete(client, paymentMethodId, paymentServiceTokenId, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do50(client, paymentMethodId, paymentServiceTokenId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do50(client, payoutId, merchantAccountId, options) {
+async function $do50(client, paymentMethodId, paymentServiceTokenId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
-    payoutId,
+    paymentMethodId,
+    paymentServiceTokenId,
+    timeoutInSeconds,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => GetPayoutRequest$outboundSchema.parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => DeletePaymentMethodPaymentServiceTokenRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
   const pathParams = {
-    payout_id: encodeSimple("payout_id", payload.payout_id, {
-      explode: false,
-      charEncoding: "percent"
-    })
+    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" }),
+    payment_service_token_id: encodeSimple("payment_service_token_id", payload.payment_service_token_id, { explode: false, charEncoding: "percent" })
   };
-  const path = pathToFunc("/payouts/{payout_id}")(pathParams);
+  const path = pathToFunc("/payment-methods/{payment_method_id}/payment-service-tokens/{payment_service_token_id}")(pathParams);
+  const query = encodeFormQuery({
+    timeout_in_seconds: payload.timeout_in_seconds
+  });
   const headers = new Headers(compactMap({
     Accept: "application/json",
     "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
@@ -54017,28 +54629,20 @@ async function $do50(client, payoutId, merchantAccountId, options) {
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "get_payout",
+    operationID: "delete_payment_method_payment_service_token",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
-    retryConfig: options?.retries || client._options.retryConfig || {
-      strategy: "backoff",
-      backoff: {
-        initialInterval: 200,
-        maxInterval: 200,
-        exponent: 1,
-        maxElapsedTime: 1000
-      },
-      retryConnectionErrors: true
-    },
-    retryCodes: options?.retryCodes || ["5XX"]
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
   };
   const requestRes = client._createRequest(context, {
     security: requestSecurity,
-    method: "GET",
+    method: "DELETE",
     baseURL: options?.serverURL,
     path,
     headers,
+    query,
     body,
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
@@ -54074,86 +54678,89 @@ async function $do50(client, payoutId, merchantAccountId, options) {
   const responseFields = {
     HttpMeta: { Response: response, Request: req }
   };
-  const [result] = await match(json(200, PayoutSummary$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetPayoutResponse403GetPayout$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  const [result] = await match(nil(204, voidType()), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, DeletePaymentMethodPaymentServiceTokenResponse403DeletePaymentMethodPaymentServiceToken$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
   if (!result.ok) {
     return [result, { status: "complete", request: req, response }];
   }
   return [result, { status: "complete", request: req, response }];
 }
-var init_payoutsGet = __esm(() => {
+var init_paymentMethodsPaymentServiceTokensDelete = __esm(() => {
+  init_lib();
   init_encodings();
   init_matchers();
   init_primitives();
   init_schemas();
   init_security();
   init_url();
-  init_components();
   init_errors();
   init_operations();
   init_async();
 });
 
-// src/mcp-server/tools/payoutsGet.ts
-var args50, tool$payoutsGet;
-var init_payoutsGet2 = __esm(() => {
+// src/mcp-server/tools/paymentMethodsPaymentServiceTokensDelete.ts
+var args50, tool$paymentMethodsPaymentServiceTokensDelete;
+var init_paymentMethodsPaymentServiceTokensDelete2 = __esm(() => {
   init_lib();
-  init_payoutsGet();
+  init_paymentMethodsPaymentServiceTokensDelete();
   init_tools();
   args50 = {
-    payoutId: stringType(),
+    paymentMethodId: stringType(),
+    paymentServiceTokenId: stringType(),
+    timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
   };
-  tool$payoutsGet = {
-    name: "payouts-get",
-    description: `Get a payout.
+  tool$paymentMethodsPaymentServiceTokensDelete = {
+    name: "payment-methods-payment-service-tokens-delete",
+    description: `Delete payment service token
 
-Retreives a payout.`,
+Delete a gateway tokens for a payment method.`,
     args: args50,
     tool: async (client, args51, ctx) => {
-      const [result, apiCall] = await payoutsGet(client, args51.payoutId, args51.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      const [result, apiCall] = await paymentMethodsPaymentServiceTokensDelete(client, args51.paymentMethodId, args51.paymentServiceTokenId, args51.timeoutInSeconds, args51.merchantAccountId, { 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);
+      return formatResult(undefined, apiCall);
     }
   };
 });
 
-// src/funcs/payoutsList.ts
-function payoutsList(client, cursor, limit, merchantAccountId, options) {
-  return new APIPromise($do51(client, cursor, limit, merchantAccountId, options));
+// src/funcs/paymentMethodsPaymentServiceTokensList.ts
+function paymentMethodsPaymentServiceTokensList(client, paymentMethodId, paymentServiceId, merchantAccountId, options) {
+  return new APIPromise($do51(client, paymentMethodId, paymentServiceId, merchantAccountId, options));
 }
-async function $do51(client, cursor, limit, merchantAccountId, options) {
+async function $do51(client, paymentMethodId, paymentServiceId, merchantAccountId, options) {
   const input = {
-    cursor,
-    limit,
+    paymentMethodId,
+    paymentServiceId,
     merchantAccountId
   };
-  const parsed = safeParse(input, (value) => ListPayoutsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  const parsed = safeParse(input, (value) => ListPaymentMethodPaymentServiceTokensRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
-    return [haltIterator(parsed), { status: "invalid" }];
+    return [parsed, { status: "invalid" }];
   }
   const payload = parsed.value;
   const body = null;
-  const path = pathToFunc("/payouts")();
+  const pathParams = {
+    payment_method_id: encodeSimple("payment_method_id", payload.payment_method_id, { explode: false, charEncoding: "percent" })
+  };
+  const path = pathToFunc("/payment-methods/{payment_method_id}/payment-service-tokens")(pathParams);
   const query = encodeFormQuery({
-    cursor: payload?.cursor,
-    limit: payload?.limit
+    payment_service_id: payload.payment_service_id
   });
   const headers = new Headers(compactMap({
     Accept: "application/json",
-    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload?.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
   }));
   const secConfig = await extractSecurity(client._options.bearerAuth);
   const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
   const requestSecurity = resolveGlobalSecurity(securityInput);
   const context = {
     baseURL: options?.serverURL ?? client._baseURL ?? "",
-    operationID: "list_payouts",
+    operationID: "list_payment_method_payment_service_tokens",
     oAuth2Scopes: [],
     resolvedSecurity: requestSecurity,
     securitySource: client._options.bearerAuth,
@@ -54180,7 +54787,538 @@ async function $do51(client, cursor, limit, merchantAccountId, options) {
     timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
   }, options);
   if (!requestRes.ok) {
-    return [haltIterator(requestRes), { status: "invalid" }];
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, CollectionNoCursorPaymentServiceToken$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentMethodPaymentServiceTokensResponse403ListPaymentMethodPaymentServiceTokens$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_paymentMethodsPaymentServiceTokensList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/paymentMethodsPaymentServiceTokensList.ts
+var args51, tool$paymentMethodsPaymentServiceTokensList;
+var init_paymentMethodsPaymentServiceTokensList2 = __esm(() => {
+  init_lib();
+  init_paymentMethodsPaymentServiceTokensList();
+  init_tools();
+  args51 = {
+    paymentMethodId: stringType(),
+    paymentServiceId: nullableType(stringType()).optional(),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$paymentMethodsPaymentServiceTokensList = {
+    name: "payment-methods-payment-service-tokens-list",
+    description: `List payment service tokens
+
+List all gateway tokens stored for a payment method.`,
+    args: args51,
+    tool: async (client, args52, ctx) => {
+      const [result, apiCall] = await paymentMethodsPaymentServiceTokensList(client, args52.paymentMethodId, args52.paymentServiceId, args52.merchantAccountId, { 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/paymentOptionsList.ts
+function paymentOptionsList(client, paymentOptionRequest, merchantAccountId, options) {
+  return new APIPromise($do52(client, paymentOptionRequest, merchantAccountId, options));
+}
+async function $do52(client, paymentOptionRequest, merchantAccountId, options) {
+  const input = {
+    paymentOptionRequest,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => ListPaymentOptionsRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.PaymentOptionRequest, {
+    explode: true
+  });
+  const path = pathToFunc("/payment-options")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list_payment_options",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, CollectionNoCursorPaymentOption$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, ListPaymentOptionsResponse403ListPaymentOptions$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_paymentOptionsList = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/paymentOptionsList.ts
+var args52, tool$paymentOptionsList;
+var init_paymentOptionsList2 = __esm(() => {
+  init_lib();
+  init_paymentOptionsList();
+  init_components();
+  init_tools();
+  args52 = {
+    paymentOptionRequest: PaymentOptionRequest$inboundSchema,
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$paymentOptionsList = {
+    name: "payment-options-list",
+    description: `List payment options
+
+List the payment options available at checkout. filtering by country, currency, and additional fields passed to Flow rules.`,
+    args: args52,
+    tool: async (client, args53, ctx) => {
+      const [result, apiCall] = await paymentOptionsList(client, args53.paymentOptionRequest, args53.merchantAccountId, { 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/payoutsCreate.ts
+function payoutsCreate(client, payoutCreate, timeoutInSeconds, merchantAccountId, options) {
+  return new APIPromise($do53(client, payoutCreate, timeoutInSeconds, merchantAccountId, options));
+}
+async function $do53(client, payoutCreate, timeoutInSeconds, merchantAccountId, options) {
+  const input = {
+    payoutCreate,
+    timeoutInSeconds,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => CreatePayoutRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.PayoutCreate, { explode: true });
+  const path = pathToFunc("/payouts")();
+  const query = encodeFormQuery({
+    timeout_in_seconds: payload.timeout_in_seconds
+  });
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "create_payout",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(201, PayoutSummary$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, CreatePayoutResponse403CreatePayout$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_payoutsCreate = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/payoutsCreate.ts
+var args53, tool$payoutsCreate;
+var init_payoutsCreate2 = __esm(() => {
+  init_lib();
+  init_payoutsCreate();
+  init_components();
+  init_tools();
+  args53 = {
+    payoutCreate: PayoutCreate$inboundSchema,
+    timeoutInSeconds: numberType().default(1),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$payoutsCreate = {
+    name: "payouts-create",
+    description: `Create a payout.
+
+Creates a new payout.`,
+    args: args53,
+    tool: async (client, args54, ctx) => {
+      const [result, apiCall] = await payoutsCreate(client, args54.payoutCreate, args54.timeoutInSeconds, args54.merchantAccountId, { 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/payoutsGet.ts
+function payoutsGet(client, payoutId, merchantAccountId, options) {
+  return new APIPromise($do54(client, payoutId, merchantAccountId, options));
+}
+async function $do54(client, payoutId, merchantAccountId, options) {
+  const input = {
+    payoutId,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => GetPayoutRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const pathParams = {
+    payout_id: encodeSimple("payout_id", payload.payout_id, {
+      explode: false,
+      charEncoding: "percent"
+    })
+  };
+  const path = pathToFunc("/payouts/{payout_id}")(pathParams);
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "get_payout",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: [
+      "400",
+      "401",
+      "403",
+      "404",
+      "405",
+      "409",
+      "422",
+      "425",
+      "429",
+      "4XX",
+      "500",
+      "502",
+      "504",
+      "5XX"
+    ],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const responseFields = {
+    HttpMeta: { Response: response, Request: req }
+  };
+  const [result] = await match(json(200, PayoutSummary$inboundSchema), jsonErr(400, Error400$inboundSchema), jsonErr(401, Error401$inboundSchema), jsonErr(403, GetPayoutResponse403GetPayout$inboundSchema), jsonErr(404, Error404$inboundSchema), jsonErr(405, Error405$inboundSchema), jsonErr(409, Error409$inboundSchema), jsonErr(422, HTTPValidationError$inboundSchema), jsonErr(425, Error425$inboundSchema), jsonErr(429, Error429$inboundSchema), jsonErr(500, Error500$inboundSchema), jsonErr(502, Error502$inboundSchema), jsonErr(504, Error504$inboundSchema), fail("4XX"), fail("5XX"))(response, { extraFields: responseFields });
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_payoutsGet = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_components();
+  init_errors();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/payoutsGet.ts
+var args54, tool$payoutsGet;
+var init_payoutsGet2 = __esm(() => {
+  init_lib();
+  init_payoutsGet();
+  init_tools();
+  args54 = {
+    payoutId: stringType(),
+    merchantAccountId: nullableType(stringType()).optional()
+  };
+  tool$payoutsGet = {
+    name: "payouts-get",
+    description: `Get a payout.
+
+Retreives a payout.`,
+    args: args54,
+    tool: async (client, args55, ctx) => {
+      const [result, apiCall] = await payoutsGet(client, args55.payoutId, args55.merchantAccountId, { 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/payoutsList.ts
+function payoutsList(client, cursor, limit, merchantAccountId, options) {
+  return new APIPromise($do55(client, cursor, limit, merchantAccountId, options));
+}
+async function $do55(client, cursor, limit, merchantAccountId, options) {
+  const input = {
+    cursor,
+    limit,
+    merchantAccountId
+  };
+  const parsed = safeParse(input, (value) => ListPayoutsRequest$outboundSchema.optional().parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [haltIterator(parsed), { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+  const path = pathToFunc("/payouts")();
+  const query = encodeFormQuery({
+    cursor: payload?.cursor,
+    limit: payload?.limit
+  });
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+    "x-gr4vy-merchant-account-id": encodeSimple("x-gr4vy-merchant-account-id", payload?.merchantAccountId ?? client._options.merchantAccountId, { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "list_payouts",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 200,
+        maxInterval: 200,
+        exponent: 1,
+        maxElapsedTime: 1000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["5XX"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    query,
+    body,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
+  }, options);
+  if (!requestRes.ok) {
+    return [haltIterator(requestRes), { status: "invalid" }];
   }
   const req = requestRes.value;
   const doResult = await client._do(req, {
@@ -54250,12 +55388,12 @@ var init_payoutsList = __esm(() => {
 });
 
 // src/mcp-server/tools/payoutsList.ts
-var args51, tool$payoutsList;
+var args55, tool$payoutsList;
 var init_payoutsList2 = __esm(() => {
   init_lib();
   init_payoutsList();
   init_tools();
-  args51 = {
+  args55 = {
     cursor: nullableType(stringType()).optional(),
     limit: numberType().int().default(20),
     merchantAccountId: nullableType(stringType()).optional()
@@ -54265,9 +55403,9 @@ var init_payoutsList2 = __esm(() => {
     description: `List payouts created.
 
 Returns a list of payouts made.`,
-    args: args51,
-    tool: async (client, args52, ctx) => {
-      const [result, apiCall] = await payoutsList(client, args52.cursor, args52.limit, args52.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args55,
+    tool: async (client, args56, ctx) => {
+      const [result, apiCall] = await payoutsList(client, args56.cursor, args56.limit, args56.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54282,9 +55420,9 @@ Returns a list of payouts made.`,
 
 // src/funcs/refundsGet.ts
 function refundsGet(client, refundId, merchantAccountId, options) {
-  return new APIPromise($do52(client, refundId, merchantAccountId, options));
+  return new APIPromise($do56(client, refundId, merchantAccountId, options));
 }
-async function $do52(client, refundId, merchantAccountId, options) {
+async function $do56(client, refundId, merchantAccountId, options) {
   const input = {
     refundId,
     merchantAccountId
@@ -54388,12 +55526,12 @@ var init_refundsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/refundsGet.ts
-var args52, tool$refundsGet;
+var args56, tool$refundsGet;
 var init_refundsGet2 = __esm(() => {
   init_lib();
   init_refundsGet();
   init_tools();
-  args52 = {
+  args56 = {
     refundId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
   };
@@ -54402,9 +55540,9 @@ var init_refundsGet2 = __esm(() => {
     description: `Get refund
 
 Fetch a refund.`,
-    args: args52,
-    tool: async (client, args53, ctx) => {
-      const [result, apiCall] = await refundsGet(client, args53.refundId, args53.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args56,
+    tool: async (client, args57, ctx) => {
+      const [result, apiCall] = await refundsGet(client, args57.refundId, args57.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54419,9 +55557,9 @@ Fetch a refund.`,
 
 // src/funcs/transactionRefundsAllCreate.ts
 function transactionRefundsAllCreate(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do53(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options));
+  return new APIPromise($do57(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do53(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options) {
+async function $do57(client, transactionId, transactionRefundAllCreate, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     transactionId,
     transactionRefundAllCreate,
@@ -54525,13 +55663,13 @@ var init_transactionRefundsAllCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionRefundsAllCreate.ts
-var args53, tool$transactionRefundsAllCreate;
+var args57, tool$transactionRefundsAllCreate;
 var init_transactionRefundsAllCreate2 = __esm(() => {
   init_lib();
   init_transactionRefundsAllCreate();
   init_components();
   init_tools();
-  args53 = {
+  args57 = {
     transactionId: stringType(),
     transactionRefundAllCreate: nullableType(TransactionRefundAllCreate$inboundSchema).optional(),
     timeoutInSeconds: numberType().default(1),
@@ -54542,9 +55680,9 @@ var init_transactionRefundsAllCreate2 = __esm(() => {
     description: `Create batch transaction refund
 
 Create a refund for all instruments on a transaction.`,
-    args: args53,
-    tool: async (client, args54, ctx) => {
-      const [result, apiCall] = await transactionRefundsAllCreate(client, args54.transactionId, args54.transactionRefundAllCreate, args54.timeoutInSeconds, args54.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args57,
+    tool: async (client, args58, ctx) => {
+      const [result, apiCall] = await transactionRefundsAllCreate(client, args58.transactionId, args58.transactionRefundAllCreate, args58.timeoutInSeconds, args58.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54559,9 +55697,9 @@ Create a refund for all instruments on a transaction.`,
 
 // src/funcs/transactionRefundsCreate.ts
 function transactionRefundsCreate(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do54(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options));
+  return new APIPromise($do58(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do54(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options) {
+async function $do58(client, transactionRefundCreate, transactionId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     transactionRefundCreate,
     transactionId,
@@ -54665,13 +55803,13 @@ var init_transactionRefundsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionRefundsCreate.ts
-var args54, tool$transactionRefundsCreate;
+var args58, tool$transactionRefundsCreate;
 var init_transactionRefundsCreate2 = __esm(() => {
   init_lib();
   init_transactionRefundsCreate();
   init_components();
   init_tools();
-  args54 = {
+  args58 = {
     transactionRefundCreate: TransactionRefundCreate$inboundSchema,
     transactionId: stringType(),
     timeoutInSeconds: numberType().default(1),
@@ -54682,9 +55820,9 @@ var init_transactionRefundsCreate2 = __esm(() => {
     description: `Create transaction refund
 
 Create a refund for a transaction.`,
-    args: args54,
-    tool: async (client, args55, ctx) => {
-      const [result, apiCall] = await transactionRefundsCreate(client, args55.transactionRefundCreate, args55.transactionId, args55.timeoutInSeconds, args55.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args58,
+    tool: async (client, args59, ctx) => {
+      const [result, apiCall] = await transactionRefundsCreate(client, args59.transactionRefundCreate, args59.transactionId, args59.timeoutInSeconds, args59.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54699,9 +55837,9 @@ Create a refund for a transaction.`,
 
 // src/funcs/transactionsCapture.ts
 function transactionsCapture(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do55(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options));
+  return new APIPromise($do59(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do55(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options) {
+async function $do59(client, transactionCapture, transactionId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     transactionCapture,
     transactionId,
@@ -54805,13 +55943,13 @@ var init_transactionsCapture = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsCapture.ts
-var args55, tool$transactionsCapture;
+var args59, tool$transactionsCapture;
 var init_transactionsCapture2 = __esm(() => {
   init_lib();
   init_transactionsCapture();
   init_components();
   init_tools();
-  args55 = {
+  args59 = {
     transactionCapture: TransactionCapture$inboundSchema,
     transactionId: stringType(),
     timeoutInSeconds: numberType().default(1),
@@ -54822,9 +55960,9 @@ var init_transactionsCapture2 = __esm(() => {
     description: `Capture transaction
 
 Capture a previously authorized transaction.`,
-    args: args55,
-    tool: async (client, args56, ctx) => {
-      const [result, apiCall] = await transactionsCapture(client, args56.transactionCapture, args56.transactionId, args56.timeoutInSeconds, args56.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args59,
+    tool: async (client, args60, ctx) => {
+      const [result, apiCall] = await transactionsCapture(client, args60.transactionCapture, args60.transactionId, args60.timeoutInSeconds, args60.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54839,9 +55977,9 @@ Capture a previously authorized transaction.`,
 
 // src/funcs/transactionsCreate.ts
 function transactionsCreate(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options) {
-  return new APIPromise($do56(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options));
+  return new APIPromise($do60(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options));
 }
-async function $do56(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options) {
+async function $do60(client, transactionCreate, timeoutInSeconds, merchantAccountId, idempotencyKey, options) {
   const input = {
     transactionCreate,
     timeoutInSeconds,
@@ -54937,13 +56075,13 @@ var init_transactionsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsCreate.ts
-var args56, tool$transactionsCreate;
+var args60, tool$transactionsCreate;
 var init_transactionsCreate2 = __esm(() => {
   init_lib();
   init_transactionsCreate();
   init_components();
   init_tools();
-  args56 = {
+  args60 = {
     transactionCreate: TransactionCreate$inboundSchema,
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional(),
@@ -54954,9 +56092,9 @@ var init_transactionsCreate2 = __esm(() => {
     description: `Create transaction
 
 Create a transaction.`,
-    args: args56,
-    tool: async (client, args57, ctx) => {
-      const [result, apiCall] = await transactionsCreate(client, args57.transactionCreate, args57.timeoutInSeconds, args57.merchantAccountId, args57.idempotencyKey, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args60,
+    tool: async (client, args61, ctx) => {
+      const [result, apiCall] = await transactionsCreate(client, args61.transactionCreate, args61.timeoutInSeconds, args61.merchantAccountId, args61.idempotencyKey, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -54971,9 +56109,9 @@ Create a transaction.`,
 
 // src/funcs/transactionsGet.ts
 function transactionsGet(client, transactionId, merchantAccountId, options) {
-  return new APIPromise($do57(client, transactionId, merchantAccountId, options));
+  return new APIPromise($do61(client, transactionId, merchantAccountId, options));
 }
-async function $do57(client, transactionId, merchantAccountId, options) {
+async function $do61(client, transactionId, merchantAccountId, options) {
   const input = {
     transactionId,
     merchantAccountId
@@ -55077,12 +56215,12 @@ var init_transactionsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsGet.ts
-var args57, tool$transactionsGet;
+var args61, tool$transactionsGet;
 var init_transactionsGet2 = __esm(() => {
   init_lib();
   init_transactionsGet();
   init_tools();
-  args57 = {
+  args61 = {
     transactionId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
   };
@@ -55091,9 +56229,9 @@ var init_transactionsGet2 = __esm(() => {
     description: `Get transaction
 
 Fetch a single transaction by its ID.`,
-    args: args57,
-    tool: async (client, args58, ctx) => {
-      const [result, apiCall] = await transactionsGet(client, args58.transactionId, args58.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args61,
+    tool: async (client, args62, ctx) => {
+      const [result, apiCall] = await transactionsGet(client, args62.transactionId, args62.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55108,9 +56246,9 @@ Fetch a single transaction by its ID.`,
 
 // src/funcs/transactionsList.ts
 function transactionsList(client, request, options) {
-  return new APIPromise($do58(client, request, options));
+  return new APIPromise($do62(client, request, options));
 }
-async function $do58(client, request, options) {
+async function $do62(client, request, options) {
   const parsed = safeParse(request, (value) => ListTransactionsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [haltIterator(parsed), { status: "invalid" }];
@@ -55266,12 +56404,12 @@ var init_transactionsList = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsList.ts
-var args58, tool$transactionsList;
+var args62, tool$transactionsList;
 var init_transactionsList2 = __esm(() => {
   init_transactionsList();
   init_operations();
   init_tools();
-  args58 = {
+  args62 = {
     request: ListTransactionsRequest$inboundSchema.optional()
   };
   tool$transactionsList = {
@@ -55279,9 +56417,9 @@ var init_transactionsList2 = __esm(() => {
     description: `List transactions
 
 List all transactions for a specific merchant account sorted by most recently created.`,
-    args: args58,
-    tool: async (client, args59, ctx) => {
-      const [result, apiCall] = await transactionsList(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args62,
+    tool: async (client, args63, ctx) => {
+      const [result, apiCall] = await transactionsList(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55296,9 +56434,9 @@ List all transactions for a specific merchant account sorted by most recently cr
 
 // src/funcs/transactionsRefundsGet.ts
 function transactionsRefundsGet(client, transactionId, refundId, merchantAccountId, options) {
-  return new APIPromise($do59(client, transactionId, refundId, merchantAccountId, options));
+  return new APIPromise($do63(client, transactionId, refundId, merchantAccountId, options));
 }
-async function $do59(client, transactionId, refundId, merchantAccountId, options) {
+async function $do63(client, transactionId, refundId, merchantAccountId, options) {
   const input = {
     transactionId,
     refundId,
@@ -55407,12 +56545,12 @@ var init_transactionsRefundsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsRefundsGet.ts
-var args59, tool$transactionsRefundsGet;
+var args63, tool$transactionsRefundsGet;
 var init_transactionsRefundsGet2 = __esm(() => {
   init_lib();
   init_transactionsRefundsGet();
   init_tools();
-  args59 = {
+  args63 = {
     transactionId: stringType(),
     refundId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
@@ -55422,9 +56560,9 @@ var init_transactionsRefundsGet2 = __esm(() => {
     description: `Get transaction refund
 
 Fetch refund for a transaction.`,
-    args: args59,
-    tool: async (client, args60, ctx) => {
-      const [result, apiCall] = await transactionsRefundsGet(client, args60.transactionId, args60.refundId, args60.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args63,
+    tool: async (client, args64, ctx) => {
+      const [result, apiCall] = await transactionsRefundsGet(client, args64.transactionId, args64.refundId, args64.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55439,9 +56577,9 @@ Fetch refund for a transaction.`,
 
 // src/funcs/transactionsRefundsList.ts
 function transactionsRefundsList(client, transactionId, merchantAccountId, options) {
-  return new APIPromise($do60(client, transactionId, merchantAccountId, options));
+  return new APIPromise($do64(client, transactionId, merchantAccountId, options));
 }
-async function $do60(client, transactionId, merchantAccountId, options) {
+async function $do64(client, transactionId, merchantAccountId, options) {
   const input = {
     transactionId,
     merchantAccountId
@@ -55545,12 +56683,12 @@ var init_transactionsRefundsList = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsRefundsList.ts
-var args60, tool$transactionsRefundsList;
+var args64, tool$transactionsRefundsList;
 var init_transactionsRefundsList2 = __esm(() => {
   init_lib();
   init_transactionsRefundsList();
   init_tools();
-  args60 = {
+  args64 = {
     transactionId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
   };
@@ -55559,9 +56697,9 @@ var init_transactionsRefundsList2 = __esm(() => {
     description: `List transaction refunds
 
 List refunds for a transaction.`,
-    args: args60,
-    tool: async (client, args61, ctx) => {
-      const [result, apiCall] = await transactionsRefundsList(client, args61.transactionId, args61.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args64,
+    tool: async (client, args65, ctx) => {
+      const [result, apiCall] = await transactionsRefundsList(client, args65.transactionId, args65.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55576,9 +56714,9 @@ List refunds for a transaction.`,
 
 // src/funcs/transactionsSummary.ts
 function transactionsSummary(client, transactionId, merchantAccountId, options) {
-  return new APIPromise($do61(client, transactionId, merchantAccountId, options));
+  return new APIPromise($do65(client, transactionId, merchantAccountId, options));
 }
-async function $do61(client, transactionId, merchantAccountId, options) {
+async function $do65(client, transactionId, merchantAccountId, options) {
   const input = {
     transactionId,
     merchantAccountId
@@ -55682,12 +56820,12 @@ var init_transactionsSummary = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsSummary.ts
-var args61, tool$transactionsSummary;
+var args65, tool$transactionsSummary;
 var init_transactionsSummary2 = __esm(() => {
   init_lib();
   init_transactionsSummary();
   init_tools();
-  args61 = {
+  args65 = {
     transactionId: stringType(),
     merchantAccountId: nullableType(stringType()).optional()
   };
@@ -55696,9 +56834,9 @@ var init_transactionsSummary2 = __esm(() => {
     description: `Get transaction summary
 
 Fetch a summary for a transaction.`,
-    args: args61,
-    tool: async (client, args62, ctx) => {
-      const [result, apiCall] = await transactionsSummary(client, args62.transactionId, args62.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args65,
+    tool: async (client, args66, ctx) => {
+      const [result, apiCall] = await transactionsSummary(client, args66.transactionId, args66.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55713,9 +56851,9 @@ Fetch a summary for a transaction.`,
 
 // src/funcs/transactionsSync.ts
 function transactionsSync(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do62(client, transactionId, timeoutInSeconds, merchantAccountId, options));
+  return new APIPromise($do66(client, transactionId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do62(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
+async function $do66(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     transactionId,
     timeoutInSeconds,
@@ -55815,12 +56953,12 @@ var init_transactionsSync = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsSync.ts
-var args62, tool$transactionsSync;
+var args66, tool$transactionsSync;
 var init_transactionsSync2 = __esm(() => {
   init_lib();
   init_transactionsSync();
   init_tools();
-  args62 = {
+  args66 = {
     transactionId: stringType(),
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
@@ -55830,9 +56968,9 @@ var init_transactionsSync2 = __esm(() => {
     description: `Sync transaction
 
 Fetch the latest status for a transaction.`,
-    args: args62,
-    tool: async (client, args63, ctx) => {
-      const [result, apiCall] = await transactionsSync(client, args63.transactionId, args63.timeoutInSeconds, args63.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args66,
+    tool: async (client, args67, ctx) => {
+      const [result, apiCall] = await transactionsSync(client, args67.transactionId, args67.timeoutInSeconds, args67.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55847,9 +56985,9 @@ Fetch the latest status for a transaction.`,
 
 // src/funcs/transactionsVoid.ts
 function transactionsVoid(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
-  return new APIPromise($do63(client, transactionId, timeoutInSeconds, merchantAccountId, options));
+  return new APIPromise($do67(client, transactionId, timeoutInSeconds, merchantAccountId, options));
 }
-async function $do63(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
+async function $do67(client, transactionId, timeoutInSeconds, merchantAccountId, options) {
   const input = {
     transactionId,
     timeoutInSeconds,
@@ -55949,12 +57087,12 @@ var init_transactionsVoid = __esm(() => {
 });
 
 // src/mcp-server/tools/transactionsVoid.ts
-var args63, tool$transactionsVoid;
+var args67, tool$transactionsVoid;
 var init_transactionsVoid2 = __esm(() => {
   init_lib();
   init_transactionsVoid();
   init_tools();
-  args63 = {
+  args67 = {
     transactionId: stringType(),
     timeoutInSeconds: numberType().default(1),
     merchantAccountId: nullableType(stringType()).optional()
@@ -55964,9 +57102,9 @@ var init_transactionsVoid2 = __esm(() => {
     description: `Void transaction
 
 Void a previously authorized transaction.`,
-    args: args63,
-    tool: async (client, args64, ctx) => {
-      const [result, apiCall] = await transactionsVoid(client, args64.transactionId, args64.timeoutInSeconds, args64.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args67,
+    tool: async (client, args68, ctx) => {
+      const [result, apiCall] = await transactionsVoid(client, args68.transactionId, args68.timeoutInSeconds, args68.merchantAccountId, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -55983,7 +57121,7 @@ Void a previously authorized transaction.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Gr4vy",
-    version: "0.18.13"
+    version: "0.18.15"
   });
   const client = new Gr4vyCore({
     bearerAuth: deps.bearerAuth,
@@ -56032,6 +57170,10 @@ function createMCPServer(deps) {
   tool(tool$checkoutSessionsUpdate);
   tool(tool$checkoutSessionsGet);
   tool(tool$checkoutSessionsDelete);
+  tool(tool$merchantAccountsList);
+  tool(tool$merchantAccountsCreate);
+  tool(tool$merchantAccountsGet);
+  tool(tool$merchantAccountsUpdate);
   tool(tool$payoutsList);
   tool(tool$payoutsCreate);
   tool(tool$payoutsGet);
@@ -56103,6 +57245,10 @@ var init_server2 = __esm(() => {
   init_giftCardsDelete2();
   init_giftCardsGet2();
   init_giftCardsList2();
+  init_merchantAccountsCreate2();
+  init_merchantAccountsGet2();
+  init_merchantAccountsList2();
+  init_merchantAccountsUpdate2();
   init_paymentMethodsCreate2();
   init_paymentMethodsDelete2();
   init_paymentMethodsGet2();
@@ -57341,7 +58487,7 @@ var routes = an({
 var app = He(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.18.13"
+    currentVersion: "0.18.15"
   }
 });
 zt(app, process3.argv.slice(2), buildContext(process3));
@@ -57349,5 +58495,5 @@ export {
   app
 };
 
-//# debugId=82A2B221BF3555F964756E2164756E21
+//# debugId=A4330F8F42BB3AF964756E2164756E21
 //# sourceMappingURL=mcp-server.js.map